RTEMS 4.10.2
Annotated Report
Tue Dec 13 20:08:41 2011

00009208 <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 ) {                                              
    9208:	e5903000 	ldr	r3, [r0]                                      
    920c:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          
)                                                                     
{                                                                     
  IMFS_jnode_t    *node = loc->node_access;                           
  IMFS_fs_info_t  *fs_info;                                           
                                                                      
  fs_info = loc->mt_entry->fs_info;                                   
    9210:	e5903010 	ldr	r3, [r0, #16]                                 
  switch( node->type ) {                                              
    9214:	e2422001 	sub	r2, r2, #1                                    
)                                                                     
{                                                                     
  IMFS_jnode_t    *node = loc->node_access;                           
  IMFS_fs_info_t  *fs_info;                                           
                                                                      
  fs_info = loc->mt_entry->fs_info;                                   
    9218:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          
  switch( node->type ) {                                              
    921c:	e3520006 	cmp	r2, #6                                        
    9220:	979ff102 	ldrls	pc, [pc, r2, lsl #2]                        
    9224:	ea000010 	b	926c <IMFS_Set_handlers+0x64>                   <== NOT EXECUTED
    9228:	00009244 	.word	0x00009244                                  <== NOT EXECUTED
    922c:	0000924c 	.word	0x0000924c                                  <== NOT EXECUTED
    9230:	00009254 	.word	0x00009254                                  <== NOT EXECUTED
    9234:	00009254 	.word	0x00009254                                  <== NOT EXECUTED
    9238:	0000925c 	.word	0x0000925c                                  <== NOT EXECUTED
    923c:	0000925c 	.word	0x0000925c                                  <== NOT EXECUTED
    9240:	00009264 	.word	0x00009264                                  <== NOT EXECUTED
    case IMFS_DIRECTORY:                                              
      loc->handlers = fs_info->directory_handlers;                    
    9244:	e593300c 	ldr	r3, [r3, #12]                                 
    9248:	ea000006 	b	9268 <IMFS_Set_handlers+0x60>                   
      break;                                                          
    case IMFS_DEVICE:                                                 
      loc->handlers = &IMFS_device_handlers;                          
    924c:	e59f3020 	ldr	r3, [pc, #32]	; 9274 <IMFS_Set_handlers+0x6c> 
    9250:	ea000004 	b	9268 <IMFS_Set_handlers+0x60>                   
      break;                                                          
    case IMFS_SYM_LINK:                                               
    case IMFS_HARD_LINK:                                              
      loc->handlers = &IMFS_link_handlers;                            
    9254:	e59f301c 	ldr	r3, [pc, #28]	; 9278 <IMFS_Set_handlers+0x70> 
    9258:	ea000002 	b	9268 <IMFS_Set_handlers+0x60>                   
      break;                                                          
    case IMFS_LINEAR_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
      break;                                                          
    case IMFS_MEMORY_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
    925c:	e5933008 	ldr	r3, [r3, #8]                                  
    9260:	ea000000 	b	9268 <IMFS_Set_handlers+0x60>                   
      break;                                                          
    case IMFS_FIFO:                                                   
      loc->handlers = &IMFS_fifo_handlers;                            
    9264:	e59f3010 	ldr	r3, [pc, #16]	; 927c <IMFS_Set_handlers+0x74> 
    9268:	e5803008 	str	r3, [r0, #8]                                  
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
    926c:	e3a00000 	mov	r0, #0                                        
    9270:	e12fff1e 	bx	lr                                             
                                                                      

000090cc <IMFS_create_node>: IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) {
    90cc:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
  IMFS_fs_info_t      *fs_info;                                       
                                                                      
  /*                                                                  
   *  MUST have a parent node to call this routine.                   
   */                                                                 
  if ( parent_loc == NULL )                                           
    90d0:	e2504000 	subs	r4, r0, #0                                   
  IMFS_jnode_types_t                type,                             
  const char                       *name,                             
  mode_t                            mode,                             
  const IMFS_types_union           *info                              
)                                                                     
{                                                                     
    90d4:	e1a05001 	mov	r5, r1                                        
    90d8:	e59d6014 	ldr	r6, [sp, #20]                                 
    90dc:	e1a01002 	mov	r1, r2                                        
  IMFS_fs_info_t      *fs_info;                                       
                                                                      
  /*                                                                  
   *  MUST have a parent node to call this routine.                   
   */                                                                 
  if ( parent_loc == NULL )                                           
    90e0:	01a07004 	moveq	r7, r4                                      
    90e4:	0a000041 	beq	91f0 <IMFS_create_node+0x124>                 
    return NULL;                                                      
                                                                      
  /*                                                                  
   *  Allocate filesystem node and fill in basic information          
   */                                                                 
  node  = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
    90e8:	e59f2108 	ldr	r2, [pc, #264]	; 91f8 <IMFS_create_node+0x12c>
    90ec:	e5922000 	ldr	r2, [r2]                                      
    90f0:	e592202c 	ldr	r2, [r2, #44]	; 0x2c                          
    90f4:	e1a00005 	mov	r0, r5                                        
    90f8:	e1c32002 	bic	r2, r3, r2                                    
    90fc:	ebffffc5 	bl	9018 <IMFS_allocate_node>                      
  if ( !node )                                                        
    9100:	e2507000 	subs	r7, r0, #0                                   
    9104:	0a000039 	beq	91f0 <IMFS_create_node+0x124>                 
    return NULL;                                                      
                                                                      
  /*                                                                  
   *  Set the type specific information                               
   */                                                                 
  switch (type) {                                                     
    9108:	e2455001 	sub	r5, r5, #1                                    
    910c:	e3550006 	cmp	r5, #6                                        
    9110:	979ff105 	ldrls	pc, [pc, r5, lsl #2]                        
    9114:	ea000025 	b	91b0 <IMFS_create_node+0xe4>                    <== NOT EXECUTED
    9118:	00009134 	.word	0x00009134                                  <== NOT EXECUTED
    911c:	00009158 	.word	0x00009158                                  <== NOT EXECUTED
    9120:	00009150 	.word	0x00009150                                  <== NOT EXECUTED
    9124:	00009150 	.word	0x00009150                                  <== NOT EXECUTED
    9128:	00009180 	.word	0x00009180                                  <== NOT EXECUTED
    912c:	00009168 	.word	0x00009168                                  <== NOT EXECUTED
    9130:	000091a4 	.word	0x000091a4                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    9134:	e2872054 	add	r2, r7, #84	; 0x54                            
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    9138:	e2873050 	add	r3, r7, #80	; 0x50                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    913c:	e5872050 	str	r2, [r7, #80]	; 0x50                          
  the_chain->permanent_null = NULL;                                   
    9140:	e3a02000 	mov	r2, #0                                        
    9144:	e5872054 	str	r2, [r7, #84]	; 0x54                          
  the_chain->last           = _Chain_Head(the_chain);                 
    9148:	e5873058 	str	r3, [r7, #88]	; 0x58                          
    914c:	ea00001c 	b	91c4 <IMFS_create_node+0xf8>                    
    case IMFS_HARD_LINK:                                              
      node->info.hard_link.link_node = info->hard_link.link_node;     
      break;                                                          
                                                                      
    case IMFS_SYM_LINK:                                               
      node->info.sym_link.name = info->sym_link.name;                 
    9150:	e5963000 	ldr	r3, [r6]                                      
    9154:	ea000013 	b	91a8 <IMFS_create_node+0xdc>                    
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      node->info.device.major = info->device.major;                   
      node->info.device.minor = info->device.minor;                   
    9158:	e5962004 	ldr	r2, [r6, #4]                                  
    case IMFS_SYM_LINK:                                               
      node->info.sym_link.name = info->sym_link.name;                 
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      node->info.device.major = info->device.major;                   
    915c:	e5963000 	ldr	r3, [r6]                                      
      node->info.device.minor = info->device.minor;                   
    9160:	e5872054 	str	r2, [r7, #84]	; 0x54                          
    9164:	ea00000f 	b	91a8 <IMFS_create_node+0xdc>                    
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      node->info.linearfile.size      = 0;                            
    9168:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    916c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    9170:	e5872050 	str	r2, [r7, #80]	; 0x50                          <== NOT EXECUTED
    9174:	e5873054 	str	r3, [r7, #84]	; 0x54                          <== NOT EXECUTED
      node->info.linearfile.direct    = 0;                            
    9178:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    917c:	e5873058 	str	r3, [r7, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    case IMFS_MEMORY_FILE:                                            
      node->info.file.size            = 0;                            
      node->info.file.indirect        = 0;                            
    9180:	e3a03000 	mov	r3, #0                                        
    case IMFS_LINEAR_FILE:                                            
      node->info.linearfile.size      = 0;                            
      node->info.linearfile.direct    = 0;                            
                                                                      
    case IMFS_MEMORY_FILE:                                            
      node->info.file.size            = 0;                            
    9184:	e3a01000 	mov	r1, #0                                        
    9188:	e3a02000 	mov	r2, #0                                        
    918c:	e5871050 	str	r1, [r7, #80]	; 0x50                          
    9190:	e5872054 	str	r2, [r7, #84]	; 0x54                          
      node->info.file.indirect        = 0;                            
      node->info.file.doubly_indirect = 0;                            
      node->info.file.triply_indirect = 0;                            
    9194:	e5873060 	str	r3, [r7, #96]	; 0x60                          
      node->info.linearfile.size      = 0;                            
      node->info.linearfile.direct    = 0;                            
                                                                      
    case IMFS_MEMORY_FILE:                                            
      node->info.file.size            = 0;                            
      node->info.file.indirect        = 0;                            
    9198:	e5873058 	str	r3, [r7, #88]	; 0x58                          
      node->info.file.doubly_indirect = 0;                            
    919c:	e587305c 	str	r3, [r7, #92]	; 0x5c                          
      node->info.file.triply_indirect = 0;                            
      break;                                                          
    91a0:	ea000007 	b	91c4 <IMFS_create_node+0xf8>                    
                                                                      
    case IMFS_FIFO:                                                   
      node->info.fifo.pipe = NULL;                                    
    91a4:	e3a03000 	mov	r3, #0                                        
    91a8:	e5873050 	str	r3, [r7, #80]	; 0x50                          
      break;                                                          
    91ac:	ea000004 	b	91c4 <IMFS_create_node+0xf8>                    
                                                                      
    default:                                                          
      assert(0);                                                      
    91b0:	e59f0044 	ldr	r0, [pc, #68]	; 91fc <IMFS_create_node+0x130> <== NOT EXECUTED
    91b4:	e3a0105c 	mov	r1, #92	; 0x5c                                <== NOT EXECUTED
    91b8:	e59f2040 	ldr	r2, [pc, #64]	; 9200 <IMFS_create_node+0x134> <== NOT EXECUTED
    91bc:	e59f3040 	ldr	r3, [pc, #64]	; 9204 <IMFS_create_node+0x138> <== NOT EXECUTED
    91c0:	eb000391 	bl	a00c <__assert_func>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This node MUST have a parent, so put it in that directory list. 
   */                                                                 
  parent       = parent_loc->node_access;                             
  fs_info      = parent_loc->mt_entry->fs_info;                       
    91c4:	e5943010 	ldr	r3, [r4, #16]                                 
    91c8:	e5932034 	ldr	r2, [r3, #52]	; 0x34                          
                                                                      
  node->Parent = parent;                                              
  node->st_ino = ++fs_info->ino_count;                                
    91cc:	e5923004 	ldr	r3, [r2, #4]                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  This node MUST have a parent, so put it in that directory list. 
   */                                                                 
  parent       = parent_loc->node_access;                             
    91d0:	e5940000 	ldr	r0, [r4]                                      
  fs_info      = parent_loc->mt_entry->fs_info;                       
                                                                      
  node->Parent = parent;                                              
  node->st_ino = ++fs_info->ino_count;                                
    91d4:	e2833001 	add	r3, r3, #1                                    
    91d8:	e5823004 	str	r3, [r2, #4]                                  
   *  This node MUST have a parent, so put it in that directory list. 
   */                                                                 
  parent       = parent_loc->node_access;                             
  fs_info      = parent_loc->mt_entry->fs_info;                       
                                                                      
  node->Parent = parent;                                              
    91dc:	e5870008 	str	r0, [r7, #8]                                  
  node->st_ino = ++fs_info->ino_count;                                
    91e0:	e5873038 	str	r3, [r7, #56]	; 0x38                          
    91e4:	e2800050 	add	r0, r0, #80	; 0x50                            
    91e8:	e1a01007 	mov	r1, r7                                        
    91ec:	ebfff215 	bl	5a48 <_Chain_Append>                           
                                                                      
  rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 
                                                                      
  return node;                                                        
}                                                                     
    91f0:	e1a00007 	mov	r0, r7                                        
    91f4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

00003e30 <IMFS_dump_directory>: rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory );
    3e30:	e3500000 	cmp	r0, #0                                        
                                                                      
void IMFS_dump_directory(                                             
  IMFS_jnode_t  *the_directory,                                       
  int            level                                                
)                                                                     
{                                                                     
    3e34:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
    3e38:	e1a05001 	mov	r5, r1                                        
  rtems_chain_node     *the_node;                                     
  rtems_chain_control  *the_chain;                                    
  IMFS_jnode_t         *the_jnode;                                    
  int                   i;                                            
                                                                      
  assert( the_directory );                                            
    3e3c:	059f00a4 	ldreq	r0, [pc, #164]	; 3ee8 <IMFS_dump_directory+0xb8>
    3e40:	03a01084 	moveq	r1, #132	; 0x84                             
    3e44:	059f20a0 	ldreq	r2, [pc, #160]	; 3eec <IMFS_dump_directory+0xbc>
    3e48:	059f30a0 	ldreq	r3, [pc, #160]	; 3ef0 <IMFS_dump_directory+0xc0>
    3e4c:	0a000005 	beq	3e68 <IMFS_dump_directory+0x38>               
                                                                      
  assert( level >= 0 );                                               
    3e50:	e3510000 	cmp	r1, #0                                        
    3e54:	aa000004 	bge	3e6c <IMFS_dump_directory+0x3c>               
    3e58:	e59f0088 	ldr	r0, [pc, #136]	; 3ee8 <IMFS_dump_directory+0xb8><== NOT EXECUTED
    3e5c:	e59f2088 	ldr	r2, [pc, #136]	; 3eec <IMFS_dump_directory+0xbc><== NOT EXECUTED
    3e60:	e59f308c 	ldr	r3, [pc, #140]	; 3ef4 <IMFS_dump_directory+0xc4><== NOT EXECUTED
    3e64:	e3a01086 	mov	r1, #134	; 0x86                               <== NOT EXECUTED
    3e68:	eb000216 	bl	46c8 <__assert_func>                           <== NOT EXECUTED
                                                                      
  assert( the_directory->type == IMFS_DIRECTORY );                    
    3e6c:	e590304c 	ldr	r3, [r0, #76]	; 0x4c                          
    3e70:	e3530001 	cmp	r3, #1                                        
    3e74:	159f006c 	ldrne	r0, [pc, #108]	; 3ee8 <IMFS_dump_directory+0xb8>
    3e78:	13a01088 	movne	r1, #136	; 0x88                             
    3e7c:	159f2068 	ldrne	r2, [pc, #104]	; 3eec <IMFS_dump_directory+0xbc>
    3e80:	159f3070 	ldrne	r3, [pc, #112]	; 3ef8 <IMFS_dump_directory+0xc8>
    3e84:	1afffff7 	bne	3e68 <IMFS_dump_directory+0x38>               
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    3e88:	e280a054 	add	sl, r0, #84	; 0x54                            
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
    3e8c:	e5904050 	ldr	r4, [r0, #80]	; 0x50                          
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    3e90:	e59f8064 	ldr	r8, [pc, #100]	; 3efc <IMFS_dump_directory+0xcc>
    IMFS_print_jnode( the_jnode );                                    
    if ( the_jnode->type == IMFS_DIRECTORY )                          
      IMFS_dump_directory( the_jnode, level + 1 );                    
    3e94:	e2817001 	add	r7, r1, #1                                    
                                                                      
  assert( the_directory->type == IMFS_DIRECTORY );                    
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
    3e98:	ea00000f 	b	3edc <IMFS_dump_directory+0xac>                 
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
    3e9c:	e3a06000 	mov	r6, #0                                        
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    3ea0:	e5983000 	ldr	r3, [r8]                                      
        !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++ )                                      
    3ea4:	e2866001 	add	r6, r6, #1                                    
      fprintf(stdout, "...." );                                       
    3ea8:	e5931008 	ldr	r1, [r3, #8]                                  
    3eac:	e59f004c 	ldr	r0, [pc, #76]	; 3f00 <IMFS_dump_directory+0xd0>
    3eb0:	eb0036d4 	bl	11a08 <fputs>                                  
        !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++ )                                      
    3eb4:	e1560005 	cmp	r6, r5                                        
    3eb8:	dafffff8 	ble	3ea0 <IMFS_dump_directory+0x70>               
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    3ebc:	e1a00004 	mov	r0, r4                                        
    3ec0:	ebffff7e 	bl	3cc0 <IMFS_print_jnode>                        
    if ( the_jnode->type == IMFS_DIRECTORY )                          
    3ec4:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    3ec8:	e3530001 	cmp	r3, #1                                        
      IMFS_dump_directory( the_jnode, level + 1 );                    
    3ecc:	01a00004 	moveq	r0, r4                                      
    3ed0:	01a01007 	moveq	r1, r7                                      
    3ed4:	0bffffd5 	bleq	3e30 <IMFS_dump_directory>                   
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
    3ed8:	e5944000 	ldr	r4, [r4]                                      
                                                                      
  assert( the_directory->type == IMFS_DIRECTORY );                    
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = the_chain->first;                                  
    3edc:	e154000a 	cmp	r4, sl                                        
    3ee0:	1affffed 	bne	3e9c <IMFS_dump_directory+0x6c>               
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( the_jnode->type == IMFS_DIRECTORY )                          
      IMFS_dump_directory( the_jnode, level + 1 );                    
  }                                                                   
}                                                                     
    3ee4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

000093cc <IMFS_eval_path>: const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) {
    93cc:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  IMFS_token_types  type = IMFS_CURRENT_DIR;                          
  char              token[ IMFS_NAME_MAX + 1 ];                       
  IMFS_jnode_t     *node;                                             
  int               result;                                           
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) ) {                       
    93d0:	e3d27007 	bics	r7, r2, #7                                   
  const char                        *pathname,     /* IN     */       
  size_t                             pathnamelen,  /* IN     */       
  int                                flags,        /* IN     */       
  rtems_filesystem_location_info_t  *pathloc       /* IN/OUT */       
                   )                                                  
{                                                                     
    93d4:	e24dd028 	sub	sp, sp, #40	; 0x28                            
    93d8:	e1a0a002 	mov	sl, r2                                        
    93dc:	e1a08000 	mov	r8, r0                                        
    93e0:	e1a06001 	mov	r6, r1                                        
    93e4:	e1a04003 	mov	r4, r3                                        
  /*                                                                  
   *  This was filled in by the caller and is valid in the            
   *  mount table.                                                    
   */                                                                 
                                                                      
  node = pathloc->node_access;                                        
    93e8:	05935000 	ldreq	r5, [r3]                                    
    93ec:	03a09001 	moveq	r9, #1                                      
  IMFS_token_types  type = IMFS_CURRENT_DIR;                          
  char              token[ IMFS_NAME_MAX + 1 ];                       
  IMFS_jnode_t     *node;                                             
  int               result;                                           
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) ) {                       
    93f0:	0a000084 	beq	9608 <IMFS_eval_path+0x23c>                   
    assert( 0 );                                                      
    93f4:	e59f02b4 	ldr	r0, [pc, #692]	; 96b0 <IMFS_eval_path+0x2e4>  <== NOT EXECUTED
    93f8:	e3a01f82 	mov	r1, #520	; 0x208                              <== NOT EXECUTED
    93fc:	e59f22b0 	ldr	r2, [pc, #688]	; 96b4 <IMFS_eval_path+0x2e8>  <== NOT EXECUTED
    9400:	e59f32b0 	ldr	r3, [pc, #688]	; 96b8 <IMFS_eval_path+0x2ec>  <== NOT EXECUTED
    9404:	eb000300 	bl	a00c <__assert_func>                           <== NOT EXECUTED
   *  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 );  
    9408:	e28d3024 	add	r3, sp, #36	; 0x24                            
    940c:	e0880007 	add	r0, r8, r7                                    
    9410:	e1a01006 	mov	r1, r6                                        
    9414:	e1a0200d 	mov	r2, sp                                        
    9418:	eb000260 	bl	9da0 <IMFS_get_token>                          
    pathnamelen -= len;                                               
    i += len;                                                         
                                                                      
    if ( !pathloc->node_access )                                      
    941c:	e5943000 	ldr	r3, [r4]                                      
    9420:	e3530000 	cmp	r3, #0                                        
   *  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 );  
    9424:	e1a09000 	mov	r9, r0                                        
    pathnamelen -= len;                                               
    9428:	e59db024 	ldr	fp, [sp, #36]	; 0x24                          
    i += len;                                                         
                                                                      
    if ( !pathloc->node_access )                                      
    942c:	0a000044 	beq	9544 <IMFS_eval_path+0x178>                   
      rtems_set_errno_and_return_minus_one( ENOENT );                 
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
    if ( type != IMFS_NO_MORE_PATH )                                  
    9430:	e3500000 	cmp	r0, #0                                        
    9434:	0a000006 	beq	9454 <IMFS_eval_path+0x88>                    
      if ( node->type == IMFS_DIRECTORY )                             
    9438:	e595104c 	ldr	r1, [r5, #76]	; 0x4c                          
    943c:	e3510001 	cmp	r1, #1                                        
    9440:	1a000003 	bne	9454 <IMFS_eval_path+0x88>                    
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
    9444:	e1a00004 	mov	r0, r4                                        
    9448:	ebffff8c 	bl	9280 <IMFS_evaluate_permission>                
    944c:	e3500000 	cmp	r0, #0                                        
    9450:	0a00008f 	beq	9694 <IMFS_eval_path+0x2c8>                   
          rtems_set_errno_and_return_minus_one( EACCES );             
                                                                      
    node = pathloc->node_access;                                      
                                                                      
    switch( type ) {                                                  
    9454:	e3590003 	cmp	r9, #3                                        
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );  
    pathnamelen -= len;                                               
    i += len;                                                         
    9458:	e087700b 	add	r7, r7, fp                                    
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );  
    pathnamelen -= len;                                               
    945c:	e06b6006 	rsb	r6, fp, r6                                    
    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;                                      
    9460:	e5945000 	ldr	r5, [r4]                                      
                                                                      
    switch( type ) {                                                  
    9464:	0a000018 	beq	94cc <IMFS_eval_path+0x100>                   
    9468:	e3590004 	cmp	r9, #4                                        
    946c:	0a000062 	beq	95fc <IMFS_eval_path+0x230>                   
    9470:	e3590002 	cmp	r9, #2                                        
    9474:	1a000063 	bne	9608 <IMFS_eval_path+0x23c>                   
      case IMFS_UP_DIR:                                               
        /*                                                            
         *  Am I at the root of all filesystems? (chroot'ed?)         
         */                                                           
                                                                      
        if ( pathloc->node_access == rtems_filesystem_root.node_access )
    9478:	e59f223c 	ldr	r2, [pc, #572]	; 96bc <IMFS_eval_path+0x2f0>  
    947c:	e5923000 	ldr	r3, [r2]                                      
    9480:	e5933018 	ldr	r3, [r3, #24]                                 
    9484:	e1550003 	cmp	r5, r3                                        
    9488:	0a00005e 	beq	9608 <IMFS_eval_path+0x23c>                   
        /*                                                            
         *  Am I at the root of this mounted filesystem?              
         */                                                           
                                                                      
        if (pathloc->node_access ==                                   
            pathloc->mt_entry->mt_fs_root.node_access) {              
    948c:	e594c010 	ldr	ip, [r4, #16]                                 
                                                                      
        /*                                                            
         *  Am I at the root of this mounted filesystem?              
         */                                                           
                                                                      
        if (pathloc->node_access ==                                   
    9490:	e59c301c 	ldr	r3, [ip, #28]                                 
    9494:	e1550003 	cmp	r5, r3                                        
    9498:	1a000005 	bne	94b4 <IMFS_eval_path+0xe8>                    
           */                                                         
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;       /* Throw out the .. in this case */          
          } else {                                                    
            *pathloc = pathloc->mt_entry->mt_point_node;              
    949c:	e28cc008 	add	ip, ip, #8                                    
    94a0:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         
    94a4:	e1a05004 	mov	r5, r4                                        
    94a8:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       
    94ac:	e1a03005 	mov	r3, r5                                        
    94b0:	ea000062 	b	9640 <IMFS_eval_path+0x274>                     
            return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),    
                                               pathnamelen+len,       
                                               flags,pathloc);        
          }                                                           
        } else {                                                      
          if ( !node->Parent )                                        
    94b4:	e5955008 	ldr	r5, [r5, #8]                                  
    94b8:	e3550000 	cmp	r5, #0                                        
    94bc:	1a00004c 	bne	95f4 <IMFS_eval_path+0x228>                   
            rtems_set_errno_and_return_minus_one( ENOENT );           
    94c0:	eb000fbf 	bl	d3c4 <__errno>                                 
    94c4:	e5809000 	str	r9, [r0]                                      
    94c8:	ea000074 	b	96a0 <IMFS_eval_path+0x2d4>                     
      case IMFS_NAME:                                                 
        /*                                                            
         *  If we are at a link follow it.                            
         */                                                           
                                                                      
        if ( node->type == IMFS_HARD_LINK ) {                         
    94cc:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
    94d0:	e3530003 	cmp	r3, #3                                        
    94d4:	1a000006 	bne	94f4 <IMFS_eval_path+0x128>                   
                                                                      
          IMFS_evaluate_hard_link( pathloc, 0 );                      
    94d8:	e1a00004 	mov	r0, r4                                        
    94dc:	e3a01000 	mov	r1, #0                                        
    94e0:	ebffff76 	bl	92c0 <IMFS_evaluate_hard_link>                 
                                                                      
          node = pathloc->node_access;                                
    94e4:	e5945000 	ldr	r5, [r4]                                      
          if ( !node )                                                
    94e8:	e3550000 	cmp	r5, #0                                        
    94ec:	1a000009 	bne	9518 <IMFS_eval_path+0x14c>                   
    94f0:	ea00000b 	b	9524 <IMFS_eval_path+0x158>                     <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one( ENOTDIR );          
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
    94f4:	e3530004 	cmp	r3, #4                                        
    94f8:	1a000006 	bne	9518 <IMFS_eval_path+0x14c>                   
                                                                      
          result = IMFS_evaluate_sym_link( pathloc, 0 );              
    94fc:	e1a00004 	mov	r0, r4                                        
    9500:	e3a01000 	mov	r1, #0                                        
    9504:	ebffff84 	bl	931c <IMFS_evaluate_sym_link>                  
                                                                      
          node = pathloc->node_access;                                
          if ( result == -1 )                                         
    9508:	e3700001 	cmn	r0, #1                                        
          if ( !node )                                                
            rtems_set_errno_and_return_minus_one( ENOTDIR );          
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
                                                                      
          result = IMFS_evaluate_sym_link( pathloc, 0 );              
    950c:	e1a0b000 	mov	fp, r0                                        
                                                                      
          node = pathloc->node_access;                                
    9510:	e5945000 	ldr	r5, [r4]                                      
          if ( result == -1 )                                         
    9514:	0a000062 	beq	96a4 <IMFS_eval_path+0x2d8>                   
                                                                      
        /*                                                            
         *  Only a directory can be decended into.                    
         */                                                           
                                                                      
        if ( node->type != IMFS_DIRECTORY )                           
    9518:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
    951c:	e3530001 	cmp	r3, #1                                        
    9520:	0a000002 	beq	9530 <IMFS_eval_path+0x164>                   
          rtems_set_errno_and_return_minus_one( ENOTDIR );            
    9524:	eb000fa6 	bl	d3c4 <__errno>                                 
    9528:	e3a03014 	mov	r3, #20                                       
    952c:	ea00005a 	b	969c <IMFS_eval_path+0x2d0>                     
                                                                      
        /*                                                            
         *  Find the token name in the current node.                  
         */                                                           
                                                                      
        node = IMFS_find_match_in_dir( node, token );                 
    9530:	e1a00005 	mov	r0, r5                                        
    9534:	e1a0100d 	mov	r1, sp                                        
    9538:	eb0001f0 	bl	9d00 <IMFS_find_match_in_dir>                  
                                                                      
        if ( !node )                                                  
    953c:	e2505000 	subs	r5, r0, #0                                   
    9540:	1a000002 	bne	9550 <IMFS_eval_path+0x184>                   
          rtems_set_errno_and_return_minus_one( ENOENT );             
    9544:	eb000f9e 	bl	d3c4 <__errno>                                 
    9548:	e3a03002 	mov	r3, #2                                        
    954c:	ea000052 	b	969c <IMFS_eval_path+0x2d0>                     
         *  file system and not the IMFS. For example the IMFS length is
         *  limited. If the token is a parent directory move back up otherwise
         *  set loc to the new fs root node and let them finish evaluating the
         *  path.                                                     
         */                                                           
        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
    9550:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
    9554:	e3530001 	cmp	r3, #1                                        
    9558:	1a000025 	bne	95f4 <IMFS_eval_path+0x228>                   
    955c:	e595305c 	ldr	r3, [r5, #92]	; 0x5c                          
    9560:	e3530000 	cmp	r3, #0                                        
    9564:	1088b007 	addne	fp, r8, r7                                  
    9568:	1a000002 	bne	9578 <IMFS_eval_path+0x1ac>                   
    956c:	ea000020 	b	95f4 <IMFS_eval_path+0x228>                     
   size_t     *len,        /* IN/OUT */                               
   int        *index       /* IN/OUT */                               
)                                                                     
{                                                                     
  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
    ++(*index);                                                       
    9570:	e2877001 	add	r7, r7, #1                                    
    --(*len);                                                         
    9574:	e2466001 	sub	r6, r6, #1                                    
   const char *path,       /* IN     */                               
   size_t     *len,        /* IN/OUT */                               
   int        *index       /* IN/OUT */                               
)                                                                     
{                                                                     
  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
    9578:	e5db0000 	ldrb	r0, [fp]                                     
    957c:	ebffe60b 	bl	2db0 <rtems_filesystem_is_separator>           
    9580:	e3500000 	cmp	r0, #0                                        
    ++(*index);                                                       
    --(*len);                                                         
    9584:	e1a0c00b 	mov	ip, fp                                        
   const char *path,       /* IN     */                               
   size_t     *len,        /* IN/OUT */                               
   int        *index       /* IN/OUT */                               
)                                                                     
{                                                                     
  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
    9588:	0a000005 	beq	95a4 <IMFS_eval_path+0x1d8>                   
    958c:	e5db3000 	ldrb	r3, [fp]                                     
    9590:	e3530000 	cmp	r3, #0                                        
    9594:	0a000002 	beq	95a4 <IMFS_eval_path+0x1d8>                   
    9598:	e3560000 	cmp	r6, #0                                        
    959c:	e28bb001 	add	fp, fp, #1                                    
    95a0:	1afffff2 	bne	9570 <IMFS_eval_path+0x1a4>                   
         *  set loc to the new fs root node and let them finish evaluating the
         *  path.                                                     
         */                                                           
        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
          IMFS_skip_separator( pathname, &pathnamelen, &i);           
          if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {     
    95a4:	e5dc3000 	ldrb	r3, [ip]                                     
    95a8:	e353002e 	cmp	r3, #46	; 0x2e                                
    95ac:	1a000003 	bne	95c0 <IMFS_eval_path+0x1f4>                   
    95b0:	e0883007 	add	r3, r8, r7                                    
    95b4:	e5d33001 	ldrb	r3, [r3, #1]                                 
    95b8:	e353002e 	cmp	r3, #46	; 0x2e                                
    95bc:	0a000009 	beq	95e8 <IMFS_eval_path+0x21c>                   
            *pathloc = node->info.directory.mt_fs->mt_fs_root;        
    95c0:	e595e05c 	ldr	lr, [r5, #92]	; 0x5c                          
    95c4:	e28ee01c 	add	lr, lr, #28                                   
    95c8:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    95cc:	e1a05004 	mov	r5, r4                                        
    95d0:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       
    95d4:	e59e2000 	ldr	r2, [lr]                                      
            return (*pathloc->ops->evalpath_h)( &pathname[i],         
    95d8:	e1a0000c 	mov	r0, ip                                        
         *  path.                                                     
         */                                                           
        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
          IMFS_skip_separator( pathname, &pathnamelen, &i);           
          if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {     
            *pathloc = node->info.directory.mt_fs->mt_fs_root;        
    95dc:	e5852000 	str	r2, [r5]                                      
            return (*pathloc->ops->evalpath_h)( &pathname[i],         
    95e0:	e1a01006 	mov	r1, r6                                        
    95e4:	ea00001b 	b	9658 <IMFS_eval_path+0x28c>                     
                                                pathnamelen,          
                                                flags, pathloc );     
          }                                                           
          i += 2;                                                     
          pathnamelen -= 2;                                           
          node = node->Parent;                                        
    95e8:	e5955008 	ldr	r5, [r5, #8]                                  
            *pathloc = node->info.directory.mt_fs->mt_fs_root;        
            return (*pathloc->ops->evalpath_h)( &pathname[i],         
                                                pathnamelen,          
                                                flags, pathloc );     
          }                                                           
          i += 2;                                                     
    95ec:	e2877002 	add	r7, r7, #2                                    
          pathnamelen -= 2;                                           
    95f0:	e2466002 	sub	r6, r6, #2                                    
                                                                      
        /*                                                            
         *  Set the node access to the point we have found.           
         */                                                           
                                                                      
        pathloc->node_access = node;                                  
    95f4:	e5845000 	str	r5, [r4]                                      
    95f8:	ea000002 	b	9608 <IMFS_eval_path+0x23c>                     
      case IMFS_NO_MORE_PATH:                                         
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
                                                                      
      case IMFS_INVALID_TOKEN:                                        
        rtems_set_errno_and_return_minus_one( ENAMETOOLONG );         
    95fc:	eb000f70 	bl	d3c4 <__errno>                                 
    9600:	e3a0305b 	mov	r3, #91	; 0x5b                                
    9604:	ea000024 	b	969c <IMFS_eval_path+0x2d0>                     
                                                                      
  /*                                                                  
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
    9608:	e3590004 	cmp	r9, #4                                        
    960c:	13590000 	cmpne	r9, #0                                      
    9610:	1affff7c 	bne	9408 <IMFS_eval_path+0x3c>                    
   *  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 ) {                               
    9614:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
    9618:	e3530001 	cmp	r3, #1                                        
    961c:	1a000014 	bne	9674 <IMFS_eval_path+0x2a8>                   
    if ( node->info.directory.mt_fs != NULL ) {                       
    9620:	e595c05c 	ldr	ip, [r5, #92]	; 0x5c                          
    9624:	e35c0000 	cmp	ip, #0                                        
    9628:	0a000011 	beq	9674 <IMFS_eval_path+0x2a8>                   
      *pathloc = node->info.directory.mt_fs->mt_fs_root;              
    962c:	e28cc01c 	add	ip, ip, #28                                   <== NOT EXECUTED
    9630:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
    9634:	e1a0e004 	mov	lr, r4                                        <== NOT EXECUTED
    9638:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
    963c:	e1a0300e 	mov	r3, lr                                        <== NOT EXECUTED
      return (*pathloc->ops->evalpath_h)( &pathname[i-len],           
    9640:	e59d1024 	ldr	r1, [sp, #36]	; 0x24                          
   *  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 ) {                       
      *pathloc = node->info.directory.mt_fs->mt_fs_root;              
    9644:	e59c2000 	ldr	r2, [ip]                                      
      return (*pathloc->ops->evalpath_h)( &pathname[i-len],           
    9648:	e0610007 	rsb	r0, r1, r7                                    
   *  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 ) {                       
      *pathloc = node->info.directory.mt_fs->mt_fs_root;              
    964c:	e5832000 	str	r2, [r3]                                      
      return (*pathloc->ops->evalpath_h)( &pathname[i-len],           
    9650:	e0880000 	add	r0, r8, r0                                    
    9654:	e0861001 	add	r1, r6, r1                                    
    9658:	e1a0200a 	mov	r2, sl                                        
    965c:	e1a03004 	mov	r3, r4                                        
    9660:	e594c00c 	ldr	ip, [r4, #12]                                 
    9664:	e1a0e00f 	mov	lr, pc                                        
    9668:	e59cf000 	ldr	pc, [ip]                                      
    966c:	e1a0b000 	mov	fp, r0                                        
    9670:	ea00000b 	b	96a4 <IMFS_eval_path+0x2d8>                     
                                          flags, pathloc );           
    } else {                                                          
      result = IMFS_Set_handlers( pathloc );                          
    }                                                                 
  } else {                                                            
    result = IMFS_Set_handlers( pathloc );                            
    9674:	e1a00004 	mov	r0, r4                                        
    9678:	ebfffee2 	bl	9208 <IMFS_Set_handlers>                       
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, flags ) )                  
    967c:	e1a0100a 	mov	r1, sl                                        
                                          flags, pathloc );           
    } else {                                                          
      result = IMFS_Set_handlers( pathloc );                          
    }                                                                 
  } else {                                                            
    result = IMFS_Set_handlers( pathloc );                            
    9680:	e1a0b000 	mov	fp, r0                                        
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, flags ) )                  
    9684:	e1a00004 	mov	r0, r4                                        
    9688:	ebfffefc 	bl	9280 <IMFS_evaluate_permission>                
    968c:	e3500000 	cmp	r0, #0                                        
    9690:	1a000003 	bne	96a4 <IMFS_eval_path+0x2d8>                   
    rtems_set_errno_and_return_minus_one( EACCES );                   
    9694:	eb000f4a 	bl	d3c4 <__errno>                                 
    9698:	e3a0300d 	mov	r3, #13                                       
    969c:	e5803000 	str	r3, [r0]                                      
    96a0:	e3e0b000 	mvn	fp, #0                                        
                                                                      
  return result;                                                      
}                                                                     
    96a4:	e1a0000b 	mov	r0, fp                                        
    96a8:	e28dd028 	add	sp, sp, #40	; 0x28                            
    96ac:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
                                                                      

00009774 <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 */ ) {
    9774:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
    9778:	e24dd028 	sub	sp, sp, #40	; 0x28                            
    977c:	e1a04001 	mov	r4, r1                                        
                                                                      
  /*                                                                  
   * This was filled in by the caller and is valid in the             
   * mount table.                                                     
   */                                                                 
  node = pathloc->node_access;                                        
    9780:	e5916000 	ldr	r6, [r1]                                      
int IMFS_evaluate_for_make(                                           
  const char                         *path,       /* IN     */        
  rtems_filesystem_location_info_t   *pathloc,    /* IN/OUT */        
  const char                        **name        /* OUT    */        
                           )                                          
{                                                                     
    9784:	e1a0a002 	mov	sl, r2                                        
    9788:	e1a08000 	mov	r8, r0                                        
  node = pathloc->node_access;                                        
                                                                      
  /*                                                                  
   * Get the path length.                                             
   */                                                                 
  pathlen = strlen( path );                                           
    978c:	eb001311 	bl	e3d8 <strlen>                                  
    9790:	e3a05000 	mov	r5, #0                                        
    9794:	e1a07000 	mov	r7, r0                                        
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    9798:	e28d3024 	add	r3, sp, #36	; 0x24                            
    979c:	e0880005 	add	r0, r8, r5                                    
    97a0:	e1a01007 	mov	r1, r7                                        
    97a4:	e1a0200d 	mov	r2, sp                                        
    97a8:	eb00017c 	bl	9da0 <IMFS_get_token>                          
    pathlen -= len;                                                   
    i +=  len;                                                        
                                                                      
    if ( !pathloc->node_access )                                      
    97ac:	e5943000 	ldr	r3, [r4]                                      
    97b0:	e3530000 	cmp	r3, #0                                        
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    97b4:	e1a09000 	mov	r9, r0                                        
    pathlen -= len;                                                   
    97b8:	e59db024 	ldr	fp, [sp, #36]	; 0x24                          
    i +=  len;                                                        
                                                                      
    if ( !pathloc->node_access )                                      
    97bc:	0a000080 	beq	99c4 <IMFS_evaluate_for_make+0x250>           
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
                                                                      
    if ( type != IMFS_NO_MORE_PATH )                                  
    97c0:	e3500000 	cmp	r0, #0                                        
    97c4:	0a000006 	beq	97e4 <IMFS_evaluate_for_make+0x70>            
      if ( node->type == IMFS_DIRECTORY )                             
    97c8:	e596104c 	ldr	r1, [r6, #76]	; 0x4c                          
    97cc:	e3510001 	cmp	r1, #1                                        
    97d0:	1a000003 	bne	97e4 <IMFS_evaluate_for_make+0x70>            
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
    97d4:	e1a00004 	mov	r0, r4                                        
    97d8:	ebfffea8 	bl	9280 <IMFS_evaluate_permission>                
    97dc:	e3500000 	cmp	r0, #0                                        
    97e0:	0a00008c 	beq	9a18 <IMFS_evaluate_for_make+0x2a4>           
           rtems_set_errno_and_return_minus_one( EACCES );            
                                                                      
    node = pathloc->node_access;                                      
    97e4:	e5943000 	ldr	r3, [r4]                                      
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    pathlen -= len;                                                   
    i +=  len;                                                        
    97e8:	e085500b 	add	r5, r5, fp                                    
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    pathlen -= len;                                                   
    97ec:	e06b7007 	rsb	r7, fp, r7                                    
    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;                                      
    97f0:	e1a06003 	mov	r6, r3                                        
                                                                      
    switch( type ) {                                                  
    97f4:	e3590004 	cmp	r9, #4                                        
    97f8:	979ff109 	ldrls	pc, [pc, r9, lsl #2]                        
    97fc:	eaffffe5 	b	9798 <IMFS_evaluate_for_make+0x24>              <== NOT EXECUTED
    9800:	00009984 	.word	0x00009984                                  <== NOT EXECUTED
    9804:	00009798 	.word	0x00009798                                  <== NOT EXECUTED
    9808:	00009814 	.word	0x00009814                                  <== NOT EXECUTED
    980c:	00009870 	.word	0x00009870                                  <== NOT EXECUTED
    9810:	00009990 	.word	0x00009990                                  <== NOT EXECUTED
      case IMFS_UP_DIR:                                               
       /*                                                             
        *  Am I at the root of all filesystems? (chroot'ed?)          
        */                                                            
                                                                      
       if ( pathloc->node_access == rtems_filesystem_root.node_access )
    9814:	e59f1218 	ldr	r1, [pc, #536]	; 9a34 <IMFS_evaluate_for_make+0x2c0>
    9818:	e5912000 	ldr	r2, [r1]                                      
    981c:	e5922018 	ldr	r2, [r2, #24]                                 
    9820:	e1530002 	cmp	r3, r2                                        
    9824:	0affffdb 	beq	9798 <IMFS_evaluate_for_make+0x24>            
                                                                      
       /*                                                             
        * Am I at the root of this mounted filesystem?                
        */                                                            
                                                                      
        if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
    9828:	e594c010 	ldr	ip, [r4, #16]                                 
    982c:	e59c201c 	ldr	r2, [ip, #28]                                 
    9830:	e1530002 	cmp	r3, r2                                        
    9834:	1a000009 	bne	9860 <IMFS_evaluate_for_make+0xec>            
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;                                                    
                                                                      
          } else {                                                    
            *pathloc = pathloc->mt_entry->mt_point_node;              
    9838:	e28cc008 	add	ip, ip, #8                                    
    983c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         
    9840:	e1a0e004 	mov	lr, r4                                        
    9844:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       
            return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
    9848:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;                                                    
                                                                      
          } else {                                                    
            *pathloc = pathloc->mt_entry->mt_point_node;              
    984c:	e59c2000 	ldr	r2, [ip]                                      
            return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
    9850:	e0635005 	rsb	r5, r3, r5                                    
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;                                                    
                                                                      
          } else {                                                    
            *pathloc = pathloc->mt_entry->mt_point_node;              
    9854:	e58e2000 	str	r2, [lr]                                      
            return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
    9858:	e0880005 	add	r0, r8, r5                                    
    985c:	ea00003c 	b	9954 <IMFS_evaluate_for_make+0x1e0>             
          }                                                           
        } else {                                                      
          if ( !node->Parent )                                        
    9860:	e5936008 	ldr	r6, [r3, #8]                                  
    9864:	e3560000 	cmp	r6, #0                                        
    9868:	1a000043 	bne	997c <IMFS_evaluate_for_make+0x208>           
    986c:	ea000054 	b	99c4 <IMFS_evaluate_for_make+0x250>             
      case IMFS_NAME:                                                 
        /*                                                            
         *  If we are at a link follow it.                            
         */                                                           
                                                                      
        if ( node->type == IMFS_HARD_LINK ) {                         
    9870:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
    9874:	e3530003 	cmp	r3, #3                                        
    9878:	0a000001 	beq	9884 <IMFS_evaluate_for_make+0x110>           
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
          if ( result == -1 )                                         
            return -1;                                                
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
    987c:	e3530004 	cmp	r3, #4                                        
    9880:	1a000005 	bne	989c <IMFS_evaluate_for_make+0x128>           
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
    9884:	e1a00004 	mov	r0, r4                                        
    9888:	e3a01000 	mov	r1, #0                                        
    988c:	ebffff8b 	bl	96c0 <IMFS_evaluate_link>                      
                                                                      
          if ( result == -1 )                                         
    9890:	e3700001 	cmn	r0, #1                                        
          if ( result == -1 )                                         
            return -1;                                                
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
    9894:	e1a06000 	mov	r6, r0                                        
                                                                      
          if ( result == -1 )                                         
    9898:	0a000062 	beq	9a28 <IMFS_evaluate_for_make+0x2b4>           
            return -1;                                                
        }                                                             
                                                                      
        node = pathloc->node_access;                                  
    989c:	e5940000 	ldr	r0, [r4]                                      
        if ( !node )                                                  
    98a0:	e3500000 	cmp	r0, #0                                        
    98a4:	0a000053 	beq	99f8 <IMFS_evaluate_for_make+0x284>           
                                                                      
        /*                                                            
         * Only a directory can be decended into.                     
         */                                                           
                                                                      
        if ( node->type != IMFS_DIRECTORY )                           
    98a8:	e590304c 	ldr	r3, [r0, #76]	; 0x4c                          
    98ac:	e3530001 	cmp	r3, #1                                        
    98b0:	1a000050 	bne	99f8 <IMFS_evaluate_for_make+0x284>           
                                                                      
        /*                                                            
         * Find the token name in the present location.               
         */                                                           
                                                                      
        node = IMFS_find_match_in_dir( node, token );                 
    98b4:	e1a0100d 	mov	r1, sp                                        
    98b8:	eb000110 	bl	9d00 <IMFS_find_match_in_dir>                  
        /*                                                            
         * If there is no node we have found the name of the node we  
         * wish to create.                                            
         */                                                           
                                                                      
        if ( ! node )                                                 
    98bc:	e2506000 	subs	r6, r0, #0                                   
    98c0:	0a000035 	beq	999c <IMFS_evaluate_for_make+0x228>           
          done = true;                                                
        else {                                                        
        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
    98c4:	e596304c 	ldr	r3, [r6, #76]	; 0x4c                          
    98c8:	e3530001 	cmp	r3, #1                                        
    98cc:	1a00002a 	bne	997c <IMFS_evaluate_for_make+0x208>           
    98d0:	e596305c 	ldr	r3, [r6, #92]	; 0x5c                          
    98d4:	e3530000 	cmp	r3, #0                                        
    98d8:	10889005 	addne	r9, r8, r5                                  
    98dc:	1a000002 	bne	98ec <IMFS_evaluate_for_make+0x178>           
    98e0:	ea000025 	b	997c <IMFS_evaluate_for_make+0x208>             
   size_t     *len,        /* IN/OUT */                               
   int        *index       /* IN/OUT */                               
)                                                                     
{                                                                     
  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
    ++(*index);                                                       
    98e4:	e2855001 	add	r5, r5, #1                                    
    --(*len);                                                         
    98e8:	e2477001 	sub	r7, r7, #1                                    
   const char *path,       /* IN     */                               
   size_t     *len,        /* IN/OUT */                               
   int        *index       /* IN/OUT */                               
)                                                                     
{                                                                     
  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
    98ec:	e5d90000 	ldrb	r0, [r9]                                     
    98f0:	ebffe52e 	bl	2db0 <rtems_filesystem_is_separator>           
    98f4:	e3500000 	cmp	r0, #0                                        
    ++(*index);                                                       
    --(*len);                                                         
    98f8:	e1a0c009 	mov	ip, r9                                        
   const char *path,       /* IN     */                               
   size_t     *len,        /* IN/OUT */                               
   int        *index       /* IN/OUT */                               
)                                                                     
{                                                                     
  while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
    98fc:	0a000005 	beq	9918 <IMFS_evaluate_for_make+0x1a4>           
    9900:	e5d93000 	ldrb	r3, [r9]                                     
    9904:	e3530000 	cmp	r3, #0                                        
    9908:	0a000002 	beq	9918 <IMFS_evaluate_for_make+0x1a4>           
    990c:	e3570000 	cmp	r7, #0                                        
    9910:	e2899001 	add	r9, r9, #1                                    
    9914:	1afffff2 	bne	98e4 <IMFS_evaluate_for_make+0x170>           
        if ( ! node )                                                 
          done = true;                                                
        else {                                                        
        if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
            IMFS_skip_separator( path, &pathlen, &i);                 
            if ((path[i] != '.') || (path[i + 1] != '.')) {           
    9918:	e5dc3000 	ldrb	r3, [ip]                                     
    991c:	e353002e 	cmp	r3, #46	; 0x2e                                
    9920:	1a000003 	bne	9934 <IMFS_evaluate_for_make+0x1c0>           
    9924:	e0883005 	add	r3, r8, r5                                    
    9928:	e5d33001 	ldrb	r3, [r3, #1]                                 
    992c:	e353002e 	cmp	r3, #46	; 0x2e                                
    9930:	0a00000e 	beq	9970 <IMFS_evaluate_for_make+0x1fc>           
              *pathloc = node->info.directory.mt_fs->mt_fs_root;      
    9934:	e596e05c 	ldr	lr, [r6, #92]	; 0x5c                          
    9938:	e28ee01c 	add	lr, lr, #28                                   
    993c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    9940:	e1a05004 	mov	r5, r4                                        
    9944:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       
    9948:	e59e2000 	ldr	r2, [lr]                                      
    994c:	e5852000 	str	r2, [r5]                                      
              return (*pathloc->ops->evalformake_h)( &path[i],        
    9950:	e1a0000c 	mov	r0, ip                                        
    9954:	e1a01004 	mov	r1, r4                                        
    9958:	e1a0200a 	mov	r2, sl                                        
    995c:	e594300c 	ldr	r3, [r4, #12]                                 
    9960:	e1a0e00f 	mov	lr, pc                                        
    9964:	e593f004 	ldr	pc, [r3, #4]                                  
    9968:	e1a06000 	mov	r6, r0                                        
    996c:	ea00002d 	b	9a28 <IMFS_evaluate_for_make+0x2b4>             
                                                     pathloc,         
                                                     name );          
            }                                                         
            i += 2;                                                   
            pathlen -= 2;                                             
            node = node->Parent;                                      
    9970:	e5966008 	ldr	r6, [r6, #8]                                  
              *pathloc = node->info.directory.mt_fs->mt_fs_root;      
              return (*pathloc->ops->evalformake_h)( &path[i],        
                                                     pathloc,         
                                                     name );          
            }                                                         
            i += 2;                                                   
    9974:	e2855002 	add	r5, r5, #2                                    
            pathlen -= 2;                                             
    9978:	e2477002 	sub	r7, r7, #2                                    
            node = node->Parent;                                      
          }                                                           
                                                                      
          pathloc->node_access = node;                                
    997c:	e5846000 	str	r6, [r4]                                      
    9980:	eaffff84 	b	9798 <IMFS_evaluate_for_make+0x24>              
        }                                                             
        break;                                                        
                                                                      
      case IMFS_NO_MORE_PATH:                                         
        rtems_set_errno_and_return_minus_one( EEXIST );               
    9984:	eb000e8e 	bl	d3c4 <__errno>                                 
    9988:	e3a03011 	mov	r3, #17                                       
    998c:	ea000023 	b	9a20 <IMFS_evaluate_for_make+0x2ac>             
        break;                                                        
                                                                      
      case IMFS_INVALID_TOKEN:                                        
        rtems_set_errno_and_return_minus_one( ENAMETOOLONG );         
    9990:	eb000e8b 	bl	d3c4 <__errno>                                 
    9994:	e3a0305b 	mov	r3, #91	; 0x5b                                
    9998:	ea000020 	b	9a20 <IMFS_evaluate_for_make+0x2ac>             
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  *name = &path[ i - len ];                                           
    999c:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
    99a0:	e0633005 	rsb	r3, r3, r5                                    
    99a4:	e0883003 	add	r3, r8, r3                                    
    99a8:	e58a3000 	str	r3, [sl]                                      
    99ac:	e0885005 	add	r5, r8, r5                                    
  /*                                                                  
   * 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++) {                                      
    99b0:	ea000006 	b	99d0 <IMFS_evaluate_for_make+0x25c>             
    if ( !IMFS_is_separator( path[ i ] ) )                            
    99b4:	ebffe4fd 	bl	2db0 <rtems_filesystem_is_separator>           
    99b8:	e3500000 	cmp	r0, #0                                        
    99bc:	e2855001 	add	r5, r5, #1                                    
    99c0:	1a000002 	bne	99d0 <IMFS_evaluate_for_make+0x25c>           
      rtems_set_errno_and_return_minus_one( ENOENT );                 
    99c4:	eb000e7e 	bl	d3c4 <__errno>                                 
    99c8:	e3a03002 	mov	r3, #2                                        
    99cc:	ea000013 	b	9a20 <IMFS_evaluate_for_make+0x2ac>             
  /*                                                                  
   * 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++) {                                      
    99d0:	e5d53000 	ldrb	r3, [r5]                                     
    99d4:	e2530000 	subs	r0, r3, #0                                   
    99d8:	1afffff5 	bne	99b4 <IMFS_evaluate_for_make+0x240>           
                                                                      
  /*                                                                  
   * Verify we can execute and write to this directory.               
   */                                                                 
                                                                      
  result = IMFS_Set_handlers( pathloc );                              
    99dc:	e1a00004 	mov	r0, r4                                        
    99e0:	ebfffe08 	bl	9208 <IMFS_Set_handlers>                       
                                                                      
  /*                                                                  
   * The returned node must be a directory                            
   */                                                                 
  node = pathloc->node_access;                                        
    99e4:	e5943000 	ldr	r3, [r4]                                      
    99e8:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
    99ec:	e3530001 	cmp	r3, #1                                        
                                                                      
  /*                                                                  
   * Verify we can execute and write to this directory.               
   */                                                                 
                                                                      
  result = IMFS_Set_handlers( pathloc );                              
    99f0:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   * The returned node must be a directory                            
   */                                                                 
  node = pathloc->node_access;                                        
    99f4:	0a000002 	beq	9a04 <IMFS_evaluate_for_make+0x290>           
  if ( node->type != IMFS_DIRECTORY )                                 
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
    99f8:	eb000e71 	bl	d3c4 <__errno>                                 
    99fc:	e3a03014 	mov	r3, #20                                       
    9a00:	ea000006 	b	9a20 <IMFS_evaluate_for_make+0x2ac>             
                                                                      
  /*                                                                  
   * We must have Write and execute permission on the returned node.  
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )   
    9a04:	e1a00004 	mov	r0, r4                                        
    9a08:	e3a01003 	mov	r1, #3                                        
    9a0c:	ebfffe1b 	bl	9280 <IMFS_evaluate_permission>                
    9a10:	e3500000 	cmp	r0, #0                                        
    9a14:	1a000003 	bne	9a28 <IMFS_evaluate_for_make+0x2b4>           
    rtems_set_errno_and_return_minus_one( EACCES );                   
    9a18:	eb000e69 	bl	d3c4 <__errno>                                 
    9a1c:	e3a0300d 	mov	r3, #13                                       
    9a20:	e5803000 	str	r3, [r0]                                      
    9a24:	e3e06000 	mvn	r6, #0                                        
                                                                      
  return result;                                                      
}                                                                     
    9a28:	e1a00006 	mov	r0, r6                                        
    9a2c:	e28dd028 	add	sp, sp, #40	; 0x28                            
    9a30:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
                                                                      

000092c0 <IMFS_evaluate_hard_link>: int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { IMFS_jnode_t *jnode = node->node_access;
    92c0:	e5903000 	ldr	r3, [r0]                                      
                                                                      
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_HARD_LINK )                                
    92c4:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          
    92c8:	e3520003 	cmp	r2, #3                                        
                                                                      
int IMFS_evaluate_hard_link(                                          
  rtems_filesystem_location_info_t  *node,   /* IN/OUT */             
  int                                flags   /* IN     */             
)                                                                     
{                                                                     
    92cc:	e92d4030 	push	{r4, r5, lr}                                 
    92d0:	e1a04000 	mov	r4, r0                                        
    92d4:	e1a05001 	mov	r5, r1                                        
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_HARD_LINK )                                
    rtems_fatal_error_occurred (0xABCD0000);                          
    92d8:	159f0038 	ldrne	r0, [pc, #56]	; 9318 <IMFS_evaluate_hard_link+0x58>
    92dc:	1bfff131 	blne	57a8 <rtems_fatal_error_occurred>            
                                                                      
  /*                                                                  
   * Set the hard link value and the handlers.                        
   */                                                                 
                                                                      
  node->node_access = jnode->info.hard_link.link_node;                
    92e0:	e5933050 	ldr	r3, [r3, #80]	; 0x50                          
    92e4:	e5803000 	str	r3, [r0]                                      
                                                                      
  IMFS_Set_handlers( node );                                          
    92e8:	ebffffc6 	bl	9208 <IMFS_Set_handlers>                       
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( node, flags ) )                     
    92ec:	e1a00004 	mov	r0, r4                                        
    92f0:	e1a01005 	mov	r1, r5                                        
    92f4:	ebffffe1 	bl	9280 <IMFS_evaluate_permission>                
    92f8:	e3500000 	cmp	r0, #0                                        
    92fc:	13a00000 	movne	r0, #0                                      
    9300:	18bd8030 	popne	{r4, r5, pc}                                
    rtems_set_errno_and_return_minus_one( EACCES );                   
    9304:	eb00102e 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9308:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
    930c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    9310:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
    9314:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00009280 <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 ) )
    9280:	e3d13007 	bics	r3, r1, #7                                   
                                                                      
int IMFS_evaluate_permission(                                         
  rtems_filesystem_location_info_t  *node,                            
  int                                flags                            
)                                                                     
{                                                                     
    9284:	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 ) )                         
    9288:	0a000004 	beq	92a0 <IMFS_evaluate_permission+0x20>          
    rtems_set_errno_and_return_minus_one( EPERM );                    
    928c:	eb00104c 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9290:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    9294:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    9298:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    929c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If all of the flags are set we have permission                   
   * to do this.                                                      
   */                                                                 
  if ( ( flags_to_test & jnode->st_mode) == flags_to_test )           
    92a0:	e5903000 	ldr	r3, [r0]                                      
    92a4:	e5930030 	ldr	r0, [r3, #48]	; 0x30                          
    92a8:	e1a01301 	lsl	r1, r1, #6                                    
    92ac:	e0010000 	and	r0, r1, r0                                    
    92b0:	e1500001 	cmp	r0, r1                                        
    92b4:	13a00000 	movne	r0, #0                                      
    92b8:	03a00001 	moveq	r0, #1                                      
    return 1;                                                         
                                                                      
  return 0;                                                           
}                                                                     
    92bc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

0000931c <IMFS_evaluate_sym_link>: int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) {
    931c:	e92d4071 	push	{r0, r4, r5, r6, lr}                         
  IMFS_jnode_t                     *jnode  = node->node_access;       
    9320:	e5906000 	ldr	r6, [r0]                                      
                                                                      
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_SYM_LINK )                                 
    9324:	e596304c 	ldr	r3, [r6, #76]	; 0x4c                          
    9328:	e3530004 	cmp	r3, #4                                        
                                                                      
int IMFS_evaluate_sym_link(                                           
  rtems_filesystem_location_info_t  *node,   /* IN/OUT */             
  int                                flags   /* IN     */             
)                                                                     
{                                                                     
    932c:	e1a04000 	mov	r4, r0                                        
    9330:	e1a05001 	mov	r5, r1                                        
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_SYM_LINK )                                 
    rtems_fatal_error_occurred (0xABCD0000);                          
    9334:	159f0088 	ldrne	r0, [pc, #136]	; 93c4 <IMFS_evaluate_sym_link+0xa8>
                                                                      
  /*                                                                  
   * Check for things that should never happen.                       
   */                                                                 
                                                                      
  if ( jnode->type != IMFS_SYM_LINK )                                 
    9338:	1a000003 	bne	934c <IMFS_evaluate_sym_link+0x30>            
    rtems_fatal_error_occurred (0xABCD0000);                          
                                                                      
  if ( !jnode->Parent )                                               
    933c:	e5963008 	ldr	r3, [r6, #8]                                  
    9340:	e3530000 	cmp	r3, #0                                        
    9344:	1a000001 	bne	9350 <IMFS_evaluate_sym_link+0x34>            
    rtems_fatal_error_occurred( 0xBAD00000 );                         
    9348:	e59f0078 	ldr	r0, [pc, #120]	; 93c8 <IMFS_evaluate_sym_link+0xac><== NOT EXECUTED
    934c:	ebfff115 	bl	57a8 <rtems_fatal_error_occurred>              <== 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;                                  
    9350:	e5843000 	str	r3, [r4]                                      
                                                                      
  rtems_filesystem_get_sym_start_loc(                                 
    9354:	e1a0100d 	mov	r1, sp                                        
    9358:	e5960050 	ldr	r0, [r6, #80]	; 0x50                          
    935c:	e1a02004 	mov	r2, r4                                        
    9360:	eb0004de 	bl	a6e0 <rtems_filesystem_get_sym_start_loc>      
                                                                      
  /*                                                                  
   * Use eval path to evaluate the path of the symbolic link.         
   */                                                                 
                                                                      
  result = IMFS_eval_path(                                            
    9364:	e59d3000 	ldr	r3, [sp]                                      
    9368:	e5966050 	ldr	r6, [r6, #80]	; 0x50                          
    936c:	e0866003 	add	r6, r6, r3                                    
    9370:	e1a00006 	mov	r0, r6                                        
    9374:	eb001417 	bl	e3d8 <strlen>                                  
    9378:	e1a02005 	mov	r2, r5                                        
    937c:	e1a01000 	mov	r1, r0                                        
    9380:	e1a03004 	mov	r3, r4                                        
    9384:	e1a00006 	mov	r0, r6                                        
    9388:	eb00000f 	bl	93cc <IMFS_eval_path>                          
    938c:	e1a06000 	mov	r6, r0                                        
    strlen( &jnode->info.sym_link.name[i] ),                          
    flags,                                                            
    node                                                              
  );                                                                  
                                                                      
  IMFS_Set_handlers( node );                                          
    9390:	e1a00004 	mov	r0, r4                                        
    9394:	ebffff9b 	bl	9208 <IMFS_Set_handlers>                       
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( node, flags ) )                     
    9398:	e1a00004 	mov	r0, r4                                        
    939c:	e1a01005 	mov	r1, r5                                        
    93a0:	ebffffb6 	bl	9280 <IMFS_evaluate_permission>                
    93a4:	e3500000 	cmp	r0, #0                                        
    93a8:	1a000003 	bne	93bc <IMFS_evaluate_sym_link+0xa0>            
    rtems_set_errno_and_return_minus_one( EACCES );                   
    93ac:	eb001004 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    93b0:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
    93b4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    93b8:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
    93bc:	e1a00006 	mov	r0, r6                                        
    93c0:	e8bd8078 	pop	{r3, r4, r5, r6, pc}                          
                                                                      

00009b98 <IMFS_fifo_close>: } int IMFS_fifo_close( rtems_libio_t *iop ) {
    9b98:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->file_info;                               
    9b9c:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
  int err = pipe_release(&JNODE2PIPE(jnode), iop);                    
    9ba0:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
}                                                                     
                                                                      
int IMFS_fifo_close(                                                  
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
    9ba4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->file_info;                               
                                                                      
  int err = pipe_release(&JNODE2PIPE(jnode), iop);                    
    9ba8:	e2840050 	add	r0, r4, #80	; 0x50                            <== NOT EXECUTED
    9bac:	ebfffc01 	bl	8bb8 <pipe_release>                            <== NOT EXECUTED
                                                                      
  if (! err) {                                                        
    9bb0:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    9bb4:	1a00000c 	bne	9bec <IMFS_fifo_close+0x54>                   <== NOT EXECUTED
    iop->flags &= ~LIBIO_FLAGS_OPEN;                                  
    9bb8:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
    9bbc:	e3c33c01 	bic	r3, r3, #256	; 0x100                          <== NOT EXECUTED
    9bc0:	e5853014 	str	r3, [r5, #20]                                 <== NOT EXECUTED
    /* Free jnode if file is already unlinked and no one opens it */  
    if (! rtems_libio_is_file_open(jnode) && jnode->st_nlink < 1)     
    9bc4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    9bc8:	eb000195 	bl	a224 <rtems_libio_is_file_open>                <== NOT EXECUTED
    9bcc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    9bd0:	1a00000a 	bne	9c00 <IMFS_fifo_close+0x68>                   <== NOT EXECUTED
    9bd4:	e1d433b4 	ldrh	r3, [r4, #52]	; 0x34                         <== NOT EXECUTED
    9bd8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    9bdc:	1a000007 	bne	9c00 <IMFS_fifo_close+0x68>                   <== NOT EXECUTED
      free(jnode);                                                    
    9be0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    9be4:	ebffe0b9 	bl	1ed0 <free>                                    <== NOT EXECUTED
    9be8:	ea000004 	b	9c00 <IMFS_fifo_close+0x68>                     <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
    9bec:	aa000003 	bge	9c00 <IMFS_fifo_close+0x68>                   <== NOT EXECUTED
    9bf0:	eb000df3 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9bf4:	e2666000 	rsb	r6, r6, #0                                    <== NOT EXECUTED
    9bf8:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
    9bfc:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
}                                                                     
    9c00:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    9c04:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00009a80 <IMFS_fifo_ioctl>: void *buffer ) { int err; if (command == FIONBIO) {
    9a80:	e59f3068 	ldr	r3, [pc, #104]	; 9af0 <IMFS_fifo_ioctl+0x70>  <== NOT EXECUTED
    9a84:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
int IMFS_fifo_ioctl(                                                  
  rtems_libio_t *iop,                                                 
  uint32_t       command,                                             
  void          *buffer                                               
)                                                                     
{                                                                     
    9a88:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
    9a8c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  int err;                                                            
                                                                      
  if (command == FIONBIO) {                                           
    9a90:	1a00000b 	bne	9ac4 <IMFS_fifo_ioctl+0x44>                   <== NOT EXECUTED
    if (buffer == NULL)                                               
    9a94:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    9a98:	03e0400d 	mvneq	r4, #13                                     <== NOT EXECUTED
    9a9c:	0a00000d 	beq	9ad8 <IMFS_fifo_ioctl+0x58>                   <== NOT EXECUTED
      err = -EFAULT;                                                  
    else {                                                            
      if (*(int *)buffer)                                             
    9aa0:	e5924000 	ldr	r4, [r2]                                      <== NOT EXECUTED
    9aa4:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
    9aa8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
        iop->flags |= LIBIO_FLAGS_NO_DELAY;                           
    9aac:	13822001 	orrne	r2, r2, #1                                  <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                          
    9ab0:	03c22001 	biceq	r2, r2, #1                                  <== NOT EXECUTED
  if (command == FIONBIO) {                                           
    if (buffer == NULL)                                               
      err = -EFAULT;                                                  
    else {                                                            
      if (*(int *)buffer)                                             
        iop->flags |= LIBIO_FLAGS_NO_DELAY;                           
    9ab4:	15832014 	strne	r2, [r3, #20]                               <== NOT EXECUTED
    9ab8:	13a04000 	movne	r4, #0                                      <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                          
    9abc:	05832014 	streq	r2, [r3, #20]                               <== NOT EXECUTED
    9ac0:	ea000008 	b	9ae8 <IMFS_fifo_ioctl+0x68>                     <== NOT EXECUTED
      return 0;                                                       
    }                                                                 
  }                                                                   
  else                                                                
    err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);          
    9ac4:	e5930038 	ldr	r0, [r3, #56]	; 0x38                          <== NOT EXECUTED
    9ac8:	e5900050 	ldr	r0, [r0, #80]	; 0x50                          <== NOT EXECUTED
    9acc:	ebfffb54 	bl	8824 <pipe_ioctl>                              <== NOT EXECUTED
                                                                      
  IMFS_FIFO_RETURN(err);                                              
    9ad0:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
    9ad4:	aa000003 	bge	9ae8 <IMFS_fifo_ioctl+0x68>                   <== NOT EXECUTED
    9ad8:	eb000e39 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9adc:	e2644000 	rsb	r4, r4, #0                                    <== NOT EXECUTED
    9ae0:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
    9ae4:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
}                                                                     
    9ae8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    9aec:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00009a38 <IMFS_fifo_lseek>: rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) {
    9a38:	e92d4031 	push	{r0, r4, r5, lr}                             <== NOT EXECUTED
  off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);       
    9a3c:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
    9a40:	e5900038 	ldr	r0, [r0, #56]	; 0x38                          <== NOT EXECUTED
    9a44:	e5900050 	ldr	r0, [r0, #80]	; 0x50                          <== NOT EXECUTED
    9a48:	ebfffb5b 	bl	87bc <pipe_lseek>                              <== NOT EXECUTED
    9a4c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    9a50:	e1a04fc3 	asr	r4, r3, #31                                   <== NOT EXECUTED
  IMFS_FIFO_RETURN(err);                                              
    9a54:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
  rtems_libio_t *iop,                                                 
  rtems_off64_t  offset,                                              
  int            whence                                               
)                                                                     
{                                                                     
  off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);       
    9a58:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  IMFS_FIFO_RETURN(err);                                              
    9a5c:	aa000004 	bge	9a74 <IMFS_fifo_lseek+0x3c>                   <== NOT EXECUTED
    9a60:	eb000e57 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9a64:	e2655000 	rsb	r5, r5, #0                                    <== NOT EXECUTED
    9a68:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
    9a6c:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
    9a70:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
}                                                                     
    9a74:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    9a78:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
    9a7c:	e8bd8038 	pop	{r3, r4, r5, pc}                              <== NOT EXECUTED
                                                                      

00009b48 <IMFS_fifo_read>: ssize_t IMFS_fifo_read( rtems_libio_t *iop, void *buffer, size_t count ) {
    9b48:	e92d4033 	push	{r0, r1, r4, r5, lr}                         <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->file_info;                               
    9b4c:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          <== NOT EXECUTED
ssize_t IMFS_fifo_read(                                               
  rtems_libio_t *iop,                                                 
  void          *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
    9b50:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->file_info;                               
                                                                      
  int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);         
    9b54:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
    9b58:	ebfffbad 	bl	8a14 <pipe_read>                               <== NOT EXECUTED
  if (err > 0)                                                        
    9b5c:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
    9b60:	da000005 	ble	9b7c <IMFS_fifo_read+0x34>                    <== NOT EXECUTED
    IMFS_update_atime(jnode);                                         
    9b64:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
    9b68:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    9b6c:	ebffe100 	bl	1f74 <gettimeofday>                            <== NOT EXECUTED
    9b70:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    9b74:	e5843040 	str	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
    9b78:	ea000004 	b	9b90 <IMFS_fifo_read+0x48>                      <== NOT EXECUTED
                                                                      
  IMFS_FIFO_RETURN(err);                                              
    9b7c:	0a000003 	beq	9b90 <IMFS_fifo_read+0x48>                    <== NOT EXECUTED
    9b80:	eb000e0f 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9b84:	e2655000 	rsb	r5, r5, #0                                    <== NOT EXECUTED
    9b88:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
    9b8c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
}                                                                     
    9b90:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    9b94:	e8bd803c 	pop	{r2, r3, r4, r5, pc}                          <== NOT EXECUTED
                                                                      

00009af4 <IMFS_fifo_write>: ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
    9af4:	e92d4033 	push	{r0, r1, r4, r5, lr}                         <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->file_info;                               
    9af8:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          <== NOT EXECUTED
ssize_t IMFS_fifo_write(                                              
  rtems_libio_t *iop,                                                 
  const void    *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
    9afc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->file_info;                               
                                                                      
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
    9b00:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
    9b04:	ebfffb5e 	bl	8884 <pipe_write>                              <== NOT EXECUTED
  if (err > 0) {                                                      
    9b08:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
    9b0c:	da000006 	ble	9b2c <IMFS_fifo_write+0x38>                   <== NOT EXECUTED
    IMFS_mtime_ctime_update(jnode);                                   
    9b10:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
    9b14:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    9b18:	ebffe115 	bl	1f74 <gettimeofday>                            <== NOT EXECUTED
    9b1c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    9b20:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
    9b24:	e5843044 	str	r3, [r4, #68]	; 0x44                          <== NOT EXECUTED
    9b28:	ea000004 	b	9b40 <IMFS_fifo_write+0x4c>                     <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
    9b2c:	0a000003 	beq	9b40 <IMFS_fifo_write+0x4c>                   <== NOT EXECUTED
    9b30:	eb000e23 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9b34:	e2655000 	rsb	r5, r5, #0                                    <== NOT EXECUTED
    9b38:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
    9b3c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
}                                                                     
    9b40:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    9b44:	e8bd803c 	pop	{r2, r3, r4, r5, pc}                          <== NOT EXECUTED
                                                                      

00009c44 <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 ) {
    9c44:	e92d4070 	push	{r4, r5, r6, lr}                             
   /*                                                                 
    * 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;     
    9c48:	e1a0c000 	mov	ip, r0                                        
    9c4c:	e5bc401c 	ldr	r4, [ip, #28]!                                
    ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
                                                                      
int IMFS_fsunmount(                                                   
  rtems_filesystem_mount_table_entry_t *temp_mt_entry                 
)                                                                     
{                                                                     
    9c50:	e1a05000 	mov	r5, r0                                        
    9c54:	e24dd014 	sub	sp, sp, #20                                   
    * 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;                                   
    9c58:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         
    9c5c:	e1a0e00d 	mov	lr, sp                                        
    9c60:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       
    9c64:	e59c3000 	ldr	r3, [ip]                                      
    9c68:	e58e3000 	str	r3, [lr]                                      
                                                                      
   /*                                                                 
    *  Set this to null to indicate that it is being unmounted.       
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
    9c6c:	e3a03000 	mov	r3, #0                                        
    9c70:	e585301c 	str	r3, [r5, #28]                                 
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
     loc.node_access = (void *)jnode;                                 
     IMFS_Set_handlers( &loc );                                       
    9c74:	e1a0500d 	mov	r5, sp                                        
    9c78:	e1a0000d 	mov	r0, sp                                        
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
     loc.node_access = (void *)jnode;                                 
    9c7c:	e58d4000 	str	r4, [sp]                                      
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
    9c80:	e5946008 	ldr	r6, [r4, #8]                                  
     loc.node_access = (void *)jnode;                                 
     IMFS_Set_handlers( &loc );                                       
    9c84:	ebfffd5f 	bl	9208 <IMFS_Set_handlers>                       
                                                                      
     if ( jnode->type != IMFS_DIRECTORY ) {                           
    9c88:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          
    9c8c:	e3520001 	cmp	r2, #1                                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    9c90:	e2843054 	add	r3, r4, #84	; 0x54                            
    9c94:	1a000002 	bne	9ca4 <IMFS_fsunmount+0x60>                    
    9c98:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          
    9c9c:	e1520003 	cmp	r2, r3                                        
    9ca0:	1a000005 	bne	9cbc <IMFS_fsunmount+0x78>                    
        result = IMFS_unlink( NULL, &loc );                           
        if (result != 0)                                              
          return -1;                                                  
        jnode = next;                                                 
     } else if ( jnode_has_no_children( jnode ) ) {                   
        result = IMFS_unlink( NULL, &loc );                           
    9ca4:	e3a00000 	mov	r0, #0                                        
    9ca8:	e1a0100d 	mov	r1, sp                                        
    9cac:	ebffdf1d 	bl	1928 <IMFS_unlink>                             
        if (result != 0)                                              
    9cb0:	e3500000 	cmp	r0, #0                                        
    9cb4:	1a00000c 	bne	9cec <IMFS_fsunmount+0xa8>                    
    9cb8:	e1a04006 	mov	r4, r6                                        
          return -1;                                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
    9cbc:	e3540000 	cmp	r4, #0                                        
    9cc0:	0a00000b 	beq	9cf4 <IMFS_fsunmount+0xb0>                    
       if ( jnode->type == IMFS_DIRECTORY ) {                         
    9cc4:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    9cc8:	e3530001 	cmp	r3, #1                                        
    9ccc:	1affffe9 	bne	9c78 <IMFS_fsunmount+0x34>                    
    9cd0:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          
    9cd4:	e2842054 	add	r2, r4, #84	; 0x54                            
    9cd8:	e1530002 	cmp	r3, r2                                        
    9cdc:	0affffe5 	beq	9c78 <IMFS_fsunmount+0x34>                    
         if ( jnode_has_children( jnode ) )                           
           jnode = jnode_get_first_child( jnode );                    
       }                                                              
     }                                                                
   } while (jnode != NULL);                                           
    9ce0:	e2534000 	subs	r4, r3, #0                                   
    9ce4:	1affffe3 	bne	9c78 <IMFS_fsunmount+0x34>                    
    9ce8:	ea000001 	b	9cf4 <IMFS_fsunmount+0xb0>                      <== NOT EXECUTED
    9cec:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    9cf0:	ea000000 	b	9cf8 <IMFS_fsunmount+0xb4>                      <== NOT EXECUTED
    9cf4:	e3a00000 	mov	r0, #0                                        
                                                                      
   return 0;                                                          
}                                                                     
    9cf8:	e28dd014 	add	sp, sp, #20                                   
    9cfc:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00001548 <IMFS_initialize_support>: IMFS_jnode_t *jnode; /* * determine/check value for imfs_memfile_bytes_per_block */ IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
    1548:	e59fc0d4 	ldr	ip, [pc, #212]	; 1624 <IMFS_initialize_support+0xdc>
    154c:	e59cc000 	ldr	ip, [ip]                                      
  rtems_filesystem_mount_table_entry_t        *temp_mt_entry,         
   const rtems_filesystem_operations_table    *op_table,              
   const rtems_filesystem_file_handlers_r     *memfile_handlers,      
   const rtems_filesystem_file_handlers_r     *directory_handlers     
)                                                                     
{                                                                     
    1550:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
    1554:	e1a08002 	mov	r8, r2                                        
    1558:	e1a06003 	mov	r6, r3                                        
    155c:	e1a04000 	mov	r4, r0                                        
    1560:	e1a07001 	mov	r7, r1                                        
  IMFS_jnode_t                          *jnode;                       
                                                                      
  /*                                                                  
   * determine/check value for imfs_memfile_bytes_per_block           
   */                                                                 
  IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,       
    1564:	e3a02000 	mov	r2, #0                                        
    1568:	e3a03010 	mov	r3, #16                                       
  int bit_mask;                                                       
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
    156c:	e153000c 	cmp	r3, ip                                        
    1570:	e2822001 	add	r2, r2, #1                                    
    1574:	0a000003 	beq	1588 <IMFS_initialize_support+0x40>           
    1578:	e3520006 	cmp	r2, #6                                        
    157c:	e1a03083 	lsl	r3, r3, #1                                    
    1580:	1afffff9 	bne	156c <IMFS_initialize_support+0x24>           
    1584:	e3a03080 	mov	r3, #128	; 0x80                               <== NOT EXECUTED
    if (bit_mask == requested_bytes_per_block) {                      
      is_valid = true;                                                
    }                                                                 
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
    1588:	e59f5098 	ldr	r5, [pc, #152]	; 1628 <IMFS_initialize_support+0xe0>
    158c:	e5853000 	str	r3, [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();
    1590:	eb001ebd 	bl	908c <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;
    1594:	e59fe090 	ldr	lr, [pc, #144]	; 162c <IMFS_initialize_support+0xe4>
  /*                                                                  
   *  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();
    1598:	e584001c 	str	r0, [r4, #28]                                 
  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;
    159c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    15a0:	e284c038 	add	ip, r4, #56	; 0x38                            
    15a4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    15a8:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    15ac:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    15b0:	e89e000f 	ldm	lr, {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;              
    15b4:	e5847028 	str	r7, [r4, #40]	; 0x28                          
  temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
    15b8:	e88c000f 	stm	ip, {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;    
    15bc:	e5846024 	str	r6, [r4, #36]	; 0x24                          
  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 ) );                    
    15c0:	e3a00001 	mov	r0, #1                                        
    15c4:	e3a01010 	mov	r1, #16                                       
    15c8:	eb0001b8 	bl	1cb0 <calloc>                                  
  if ( !fs_info ) {                                                   
    15cc:	e3500000 	cmp	r0, #0                                        
    15d0:	1a000006 	bne	15f0 <IMFS_initialize_support+0xa8>           
    free(temp_mt_entry->mt_fs_root.node_access);                      
    15d4:	e594001c 	ldr	r0, [r4, #28]                                 <== NOT EXECUTED
    15d8:	eb00023c 	bl	1ed0 <free>                                    <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
    15dc:	eb002f78 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    15e0:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    15e4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    15e8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    15ec:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
    15f0:	e5952004 	ldr	r2, [r5, #4]                                  
  fs_info->ino_count             = 1;                                 
  fs_info->memfile_handlers      = memfile_handlers;                  
  fs_info->directory_handlers    = directory_handlers;                
                                                                      
  jnode = temp_mt_entry->mt_fs_root.node_access;                      
  jnode->st_ino = fs_info->ino_count;                                 
    15f4:	e594101c 	ldr	r1, [r4, #28]                                 
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
  fs_info->ino_count             = 1;                                 
    15f8:	e3a03001 	mov	r3, #1                                        
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
    15fc:	e880000c 	stm	r0, {r2, r3}                                  
  fs_info->ino_count             = 1;                                 
  fs_info->memfile_handlers      = memfile_handlers;                  
  fs_info->directory_handlers    = directory_handlers;                
    1600:	e580600c 	str	r6, [r0, #12]                                 
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
  fs_info->ino_count             = 1;                                 
  fs_info->memfile_handlers      = memfile_handlers;                  
    1604:	e5808008 	str	r8, [r0, #8]                                  
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
    1608:	e0822003 	add	r2, r2, r3                                    
  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;                                   
    160c:	e5840034 	str	r0, [r4, #52]	; 0x34                          
  fs_info->ino_count             = 1;                                 
  fs_info->memfile_handlers      = memfile_handlers;                  
  fs_info->directory_handlers    = directory_handlers;                
                                                                      
  jnode = temp_mt_entry->mt_fs_root.node_access;                      
  jnode->st_ino = fs_info->ino_count;                                 
    1610:	e5813038 	str	r3, [r1, #56]	; 0x38                          
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
    1614:	e5852004 	str	r2, [r5, #4]                                  
                                                                      
  jnode = temp_mt_entry->mt_fs_root.node_access;                      
  jnode->st_ino = fs_info->ino_count;                                 
                                                                      
  /* Initialize POSIX FIFO/pipe module */                             
  rtems_pipe_initialize();                                            
    1618:	eb001c69 	bl	87c4 <rtems_pipe_initialize>                   
    161c:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
    1620:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

00001630 <IMFS_link>: int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) {
    1630:	e92d4070 	push	{r4, r5, r6, lr}                             
  int                i;                                               
                                                                      
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
  info.hard_link.link_node = to_loc->node_access;                     
    1634:	e5903000 	ldr	r3, [r0]                                      
int IMFS_link(                                                        
  rtems_filesystem_location_info_t  *to_loc,      /* IN */            
  rtems_filesystem_location_info_t  *parent_loc,  /* IN */            
  const char                        *token        /* IN */            
)                                                                     
{                                                                     
    1638:	e24dd048 	sub	sp, sp, #72	; 0x48                            
  int                i;                                               
                                                                      
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
  info.hard_link.link_node = to_loc->node_access;                     
    163c:	e58d3028 	str	r3, [sp, #40]	; 0x28                          
  if ( info.hard_link.link_node->st_nlink >= LINK_MAX )               
    1640:	e1d333b4 	ldrh	r3, [r3, #52]	; 0x34                         
    1644:	e3530007 	cmp	r3, #7                                        
int IMFS_link(                                                        
  rtems_filesystem_location_info_t  *to_loc,      /* IN */            
  rtems_filesystem_location_info_t  *parent_loc,  /* IN */            
  const char                        *token        /* IN */            
)                                                                     
{                                                                     
    1648:	e1a05001 	mov	r5, r1                                        
    164c:	e1a06002 	mov	r6, r2                                        
                                                                      
  /*                                                                  
   *  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 )               
    1650:	9a000002 	bls	1660 <IMFS_link+0x30>                         
    rtems_set_errno_and_return_minus_one( EMLINK );                   
    1654:	eb002f5a 	bl	d3c4 <__errno>                                 
    1658:	e3a0301f 	mov	r3, #31                                       
    165c:	ea000012 	b	16ac <IMFS_link+0x7c>                           
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
  IMFS_get_token( token, strlen( token ), new_name, &i );             
    1660:	e1a00002 	mov	r0, r2                                        
    1664:	eb00335b 	bl	e3d8 <strlen>                                  
    1668:	e28d4004 	add	r4, sp, #4                                    
    166c:	e1a01000 	mov	r1, r0                                        
    1670:	e1a02004 	mov	r2, r4                                        
    1674:	e28d3044 	add	r3, sp, #68	; 0x44                            
    1678:	e1a00006 	mov	r0, r6                                        
    167c:	eb0021c7 	bl	9da0 <IMFS_get_token>                          
   *        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(                                        
    1680:	e28dc028 	add	ip, sp, #40	; 0x28                            
    1684:	e1a00005 	mov	r0, r5                                        
    1688:	e1a02004 	mov	r2, r4                                        
    168c:	e3a01003 	mov	r1, #3                                        
    1690:	e59f3054 	ldr	r3, [pc, #84]	; 16ec <IMFS_link+0xbc>         
    1694:	e58dc000 	str	ip, [sp]                                      
    1698:	eb001e8b 	bl	90cc <IMFS_create_node>                        
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if ( !new_node )                                                    
    169c:	e3500000 	cmp	r0, #0                                        
    16a0:	1a000004 	bne	16b8 <IMFS_link+0x88>                         
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
    16a4:	eb002f46 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    16a8:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    16ac:	e5803000 	str	r3, [r0]                                      
    16b0:	e3e00000 	mvn	r0, #0                                        
    16b4:	ea00000a 	b	16e4 <IMFS_link+0xb4>                           
                                                                      
  /*                                                                  
   * Increment the link count of the node being pointed to.           
   */                                                                 
  info.hard_link.link_node->st_nlink++;                               
    16b8:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          
    16bc:	e1d323b4 	ldrh	r2, [r3, #52]	; 0x34                         
    16c0:	e2822001 	add	r2, r2, #1                                    
    16c4:	e1c323b4 	strh	r2, [r3, #52]	; 0x34                         
  IMFS_update_ctime( info.hard_link.link_node );                      
    16c8:	e28d003c 	add	r0, sp, #60	; 0x3c                            
    16cc:	e3a01000 	mov	r1, #0                                        
    16d0:	eb000227 	bl	1f74 <gettimeofday>                            
    16d4:	e59d203c 	ldr	r2, [sp, #60]	; 0x3c                          
    16d8:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          
    16dc:	e5832048 	str	r2, [r3, #72]	; 0x48                          
    16e0:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
    16e4:	e28dd048 	add	sp, sp, #72	; 0x48                            
    16e8:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

0000bcbc <IMFS_memfile_addblock>: ) { block_p memory; block_p *block_entry_ptr; assert( the_jnode );
    bcbc:	e2503000 	subs	r3, r0, #0                                   
                                                                      
MEMFILE_STATIC int IMFS_memfile_addblock(                             
   IMFS_jnode_t  *the_jnode,                                          
   unsigned int   block                                               
)                                                                     
{                                                                     
    bcc0:	e92d4030 	push	{r4, r5, lr}                                 
  block_p  memory;                                                    
  block_p *block_entry_ptr;                                           
                                                                      
  assert( the_jnode );                                                
    bcc4:	059f0060 	ldreq	r0, [pc, #96]	; bd2c <IMFS_memfile_addblock+0x70>
    bcc8:	059f1060 	ldreq	r1, [pc, #96]	; bd30 <IMFS_memfile_addblock+0x74>
    bccc:	059f2060 	ldreq	r2, [pc, #96]	; bd34 <IMFS_memfile_addblock+0x78>
    bcd0:	059f3060 	ldreq	r3, [pc, #96]	; bd38 <IMFS_memfile_addblock+0x7c>
    bcd4:	0a000006 	beq	bcf4 <IMFS_memfile_addblock+0x38>             
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
    bcd8:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
    bcdc:	e3530005 	cmp	r3, #5                                        
    bce0:	0a000004 	beq	bcf8 <IMFS_memfile_addblock+0x3c>             
    bce4:	e59f0040 	ldr	r0, [pc, #64]	; bd2c <IMFS_memfile_addblock+0x70><== NOT EXECUTED
    bce8:	e59f104c 	ldr	r1, [pc, #76]	; bd3c <IMFS_memfile_addblock+0x80><== NOT EXECUTED
    bcec:	e59f2040 	ldr	r2, [pc, #64]	; bd34 <IMFS_memfile_addblock+0x78><== NOT EXECUTED
    bcf0:	e59f3048 	ldr	r3, [pc, #72]	; bd40 <IMFS_memfile_addblock+0x84><== NOT EXECUTED
    bcf4:	ebfff8c4 	bl	a00c <__assert_func>                           <== NOT EXECUTED
  if ( the_jnode->type != IMFS_MEMORY_FILE )                          
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
    bcf8:	e3a02001 	mov	r2, #1                                        
    bcfc:	ebfffeaf 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
  if ( *block_entry_ptr )                                             
    bd00:	e5904000 	ldr	r4, [r0]                                      
    bd04:	e3540000 	cmp	r4, #0                                        
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
  if ( the_jnode->type != IMFS_MEMORY_FILE )                          
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
    bd08:	e1a05000 	mov	r5, r0                                        
  if ( *block_entry_ptr )                                             
    bd0c:	13a00000 	movne	r0, #0                                      
    bd10:	18bd8030 	popne	{r4, r5, pc}                                
#if 0                                                                 
  fprintf(stdout, "%d %p", block, block_entry_ptr );                  
    fflush(stdout);                                                   
#endif                                                                
                                                                      
  memory = memfile_alloc_block();                                     
    bd14:	ebfffe9c 	bl	b78c <memfile_alloc_block>                     
  if ( !memory )                                                      
    bd18:	e3500000 	cmp	r0, #0                                        
    return 1;                                                         
  *block_entry_ptr = memory;                                          
    bd1c:	15850000 	strne	r0, [r5]                                    
  fprintf(stdout, "%d %p", block, block_entry_ptr );                  
    fflush(stdout);                                                   
#endif                                                                
                                                                      
  memory = memfile_alloc_block();                                     
  if ( !memory )                                                      
    bd20:	03a00001 	moveq	r0, #1                                      
    return 1;                                                         
  *block_entry_ptr = memory;                                          
    bd24:	11a00004 	movne	r0, r4                                      
                                                                      
  return 0;                                                           
}                                                                     
    bd28:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

0000bd44 <IMFS_memfile_extend>: MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) {
    bd44:	e92d4df1 	push	{r0, r4, r5, r6, r7, r8, sl, fp, lr}         
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    bd48:	e2504000 	subs	r4, r0, #0                                   
                                                                      
MEMFILE_STATIC int IMFS_memfile_extend(                               
   IMFS_jnode_t  *the_jnode,                                          
   off_t          new_length                                          
)                                                                     
{                                                                     
    bd4c:	e1a05001 	mov	r5, r1                                        
    bd50:	e1a06002 	mov	r6, r2                                        
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    bd54:	059f0134 	ldreq	r0, [pc, #308]	; be90 <IMFS_memfile_extend+0x14c>
    bd58:	059f1134 	ldreq	r1, [pc, #308]	; be94 <IMFS_memfile_extend+0x150>
    bd5c:	059f2134 	ldreq	r2, [pc, #308]	; be98 <IMFS_memfile_extend+0x154>
    bd60:	059f3134 	ldreq	r3, [pc, #308]	; be9c <IMFS_memfile_extend+0x158>
    bd64:	0a000006 	beq	bd84 <IMFS_memfile_extend+0x40>               
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
    bd68:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    bd6c:	e3530005 	cmp	r3, #5                                        
    bd70:	0a000004 	beq	bd88 <IMFS_memfile_extend+0x44>               
    bd74:	e59f0114 	ldr	r0, [pc, #276]	; be90 <IMFS_memfile_extend+0x14c><== NOT EXECUTED
    bd78:	e59f1120 	ldr	r1, [pc, #288]	; bea0 <IMFS_memfile_extend+0x15c><== NOT EXECUTED
    bd7c:	e59f2114 	ldr	r2, [pc, #276]	; be98 <IMFS_memfile_extend+0x154><== NOT EXECUTED
    bd80:	e59f311c 	ldr	r3, [pc, #284]	; bea4 <IMFS_memfile_extend+0x160><== NOT EXECUTED
    bd84:	ebfff8a0 	bl	a00c <__assert_func>                           <== NOT EXECUTED
  if ( the_jnode->type != IMFS_MEMORY_FILE )                          
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
    bd88:	e59f3118 	ldr	r3, [pc, #280]	; bea8 <IMFS_memfile_extend+0x164>
    bd8c:	e593b000 	ldr	fp, [r3]                                      
    bd90:	e1a0312b 	lsr	r3, fp, #2                                    
    bd94:	e2832001 	add	r2, r3, #1                                    
    bd98:	e0010293 	mul	r1, r3, r2                                    
    bd9c:	e2811001 	add	r1, r1, #1                                    
    bda0:	e0020193 	mul	r2, r3, r1                                    
    bda4:	e3a03000 	mov	r3, #0                                        
    bda8:	e1530006 	cmp	r3, r6                                        
    bdac:	e2422001 	sub	r2, r2, #1                                    
    bdb0:	e003029b 	mul	r3, fp, r2                                    
    bdb4:	ca000005 	bgt	bdd0 <IMFS_memfile_extend+0x8c>               
    bdb8:	1a000001 	bne	bdc4 <IMFS_memfile_extend+0x80>               
    bdbc:	e1530005 	cmp	r3, r5                                        
    bdc0:	8a000002 	bhi	bdd0 <IMFS_memfile_extend+0x8c>               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    bdc4:	eb00057e 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    bdc8:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    bdcc:	ea000025 	b	be68 <IMFS_memfile_extend+0x124>                <== NOT EXECUTED
                                                                      
  if ( new_length <= the_jnode->info.file.size )                      
    bdd0:	e5948054 	ldr	r8, [r4, #84]	; 0x54                          
    bdd4:	e1560008 	cmp	r6, r8                                        
    bdd8:	e5947050 	ldr	r7, [r4, #80]	; 0x50                          
    bddc:	ca000002 	bgt	bdec <IMFS_memfile_extend+0xa8>               
    bde0:	1a000028 	bne	be88 <IMFS_memfile_extend+0x144>              
    bde4:	e1550007 	cmp	r5, r7                                        
    bde8:	9a000026 	bls	be88 <IMFS_memfile_extend+0x144>              
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
                                                                      
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
    bdec:	e1a0cfcb 	asr	ip, fp, #31                                   
    bdf0:	e1a0300c 	mov	r3, ip                                        
    bdf4:	e1a0200b 	mov	r2, fp                                        
    bdf8:	e1a00005 	mov	r0, r5                                        
    bdfc:	e1a01006 	mov	r1, r6                                        
    be00:	e58dc000 	str	ip, [sp]                                      
    be04:	eb002e39 	bl	176f0 <__divdi3>                               
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
    be08:	e59dc000 	ldr	ip, [sp]                                      
    be0c:	e1a01008 	mov	r1, r8                                        
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
                                                                      
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
    be10:	e1a0a000 	mov	sl, r0                                        
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
    be14:	e1a0200b 	mov	r2, fp                                        
    be18:	e1a00007 	mov	r0, r7                                        
    be1c:	e1a0300c 	mov	r3, ip                                        
    be20:	eb002e32 	bl	176f0 <__divdi3>                               
    be24:	e1a08000 	mov	r8, r0                                        
    be28:	e1a07000 	mov	r7, r0                                        
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
                                                                      
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    be2c:	ea000011 	b	be78 <IMFS_memfile_extend+0x134>                
    if ( IMFS_memfile_addblock( the_jnode, block ) ) {                
    be30:	e1a00004 	mov	r0, r4                                        
    be34:	e1a01007 	mov	r1, r7                                        
    be38:	ebffff9f 	bl	bcbc <IMFS_memfile_addblock>                   
    be3c:	e3500000 	cmp	r0, #0                                        
    be40:	0a00000b 	beq	be74 <IMFS_memfile_extend+0x130>              
    be44:	ea000003 	b	be58 <IMFS_memfile_extend+0x114>                <== NOT EXECUTED
       for ( ; block>=old_blocks ; block-- ) {                        
          IMFS_memfile_remove_block( the_jnode, block );              
    be48:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    be4c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    be50:	ebfffefa 	bl	ba40 <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-- ) {                        
    be54:	e2477001 	sub	r7, r7, #1                                    <== NOT EXECUTED
    be58:	e1570008 	cmp	r7, r8                                        <== NOT EXECUTED
    be5c:	2afffff9 	bcs	be48 <IMFS_memfile_extend+0x104>              <== NOT EXECUTED
          IMFS_memfile_remove_block( the_jnode, block );              
       }                                                              
       rtems_set_errno_and_return_minus_one( ENOSPC );                
    be60:	eb000557 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    be64:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
    be68:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    be6c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    be70:	ea000005 	b	be8c <IMFS_memfile_extend+0x148>                <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
                                                                      
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    be74:	e2877001 	add	r7, r7, #1                                    
    be78:	e157000a 	cmp	r7, sl                                        
    be7c:	9affffeb 	bls	be30 <IMFS_memfile_extend+0xec>               
                                                                      
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
                                                                      
  the_jnode->info.file.size = new_length;                             
    be80:	e5846054 	str	r6, [r4, #84]	; 0x54                          
    be84:	e5845050 	str	r5, [r4, #80]	; 0x50                          
    be88:	e3a00000 	mov	r0, #0                                        
  return 0;                                                           
}                                                                     
    be8c:	e8bd8df8 	pop	{r3, r4, r5, r6, r7, r8, sl, fp, pc}          
                                                                      

0000b7c0 <IMFS_memfile_get_block_pointer>: #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) {
    b7c0:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    b7c4:	e2504000 	subs	r4, r0, #0                                   
#endif                                                                
   IMFS_jnode_t   *the_jnode,                                         
   unsigned int    block,                                             
   int             malloc_it                                          
)                                                                     
{                                                                     
    b7c8:	e1a06001 	mov	r6, r1                                        
    b7cc:	e1a08002 	mov	r8, r2                                        
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    b7d0:	059f01d8 	ldreq	r0, [pc, #472]	; b9b0 <IMFS_memfile_get_block_pointer+0x1f0>
    b7d4:	03a01fe2 	moveq	r1, #904	; 0x388                            
    b7d8:	059f21d4 	ldreq	r2, [pc, #468]	; b9b4 <IMFS_memfile_get_block_pointer+0x1f4>
    b7dc:	059f31d4 	ldreq	r3, [pc, #468]	; b9b8 <IMFS_memfile_get_block_pointer+0x1f8>
    b7e0:	0a000006 	beq	b800 <IMFS_memfile_get_block_pointer+0x40>    
  if ( !the_jnode )                                                   
    return NULL;                                                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
    b7e4:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    b7e8:	e3530005 	cmp	r3, #5                                        
    b7ec:	0a000004 	beq	b804 <IMFS_memfile_get_block_pointer+0x44>    
    b7f0:	e59f01b8 	ldr	r0, [pc, #440]	; b9b0 <IMFS_memfile_get_block_pointer+0x1f0><== NOT EXECUTED
    b7f4:	e59f21b8 	ldr	r2, [pc, #440]	; b9b4 <IMFS_memfile_get_block_pointer+0x1f4><== NOT EXECUTED
    b7f8:	e59f31bc 	ldr	r3, [pc, #444]	; b9bc <IMFS_memfile_get_block_pointer+0x1fc><== NOT EXECUTED
    b7fc:	e3a01fe3 	mov	r1, #908	; 0x38c                              <== NOT EXECUTED
    b800:	ebfffa01 	bl	a00c <__assert_func>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_INDIRECT ) {                                  
    b804:	e59f31b4 	ldr	r3, [pc, #436]	; b9c0 <IMFS_memfile_get_block_pointer+0x200>
    b808:	e5935000 	ldr	r5, [r3]                                      
    b80c:	e1a05125 	lsr	r5, r5, #2                                    
    b810:	e2453001 	sub	r3, r5, #1                                    
    b814:	e1510003 	cmp	r1, r3                                        
    b818:	8a00000e 	bhi	b858 <IMFS_memfile_get_block_pointer+0x98>    
fprintf(stdout, "(s %d) ", block );                                   
fflush(stdout);                                                       
#endif                                                                
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
    b81c:	e3520000 	cmp	r2, #0                                        
  if ( my_block <= LAST_INDIRECT ) {                                  
#if 0                                                                 
fprintf(stdout, "(s %d) ", block );                                   
fflush(stdout);                                                       
#endif                                                                
    p = info->indirect;                                               
    b820:	e5940058 	ldr	r0, [r4, #88]	; 0x58                          
                                                                      
    if ( malloc_it ) {                                                
    b824:	0a000007 	beq	b848 <IMFS_memfile_get_block_pointer+0x88>    
                                                                      
      if ( !p ) {                                                     
    b828:	e3500000 	cmp	r0, #0                                        
    b82c:	1a000003 	bne	b840 <IMFS_memfile_get_block_pointer+0x80>    
        p = memfile_alloc_block();                                    
    b830:	ebffffd5 	bl	b78c <memfile_alloc_block>                     
        if ( !p )                                                     
    b834:	e3500000 	cmp	r0, #0                                        
    b838:	0a00005a 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   
           return 0;                                                  
        info->indirect = p;                                           
    b83c:	e5840058 	str	r0, [r4, #88]	; 0x58                          
      }                                                               
      return &info->indirect[ my_block ];                             
    b840:	e5940058 	ldr	r0, [r4, #88]	; 0x58                          
    b844:	ea000001 	b	b850 <IMFS_memfile_get_block_pointer+0x90>      
    }                                                                 
                                                                      
    if ( !p )                                                         
    b848:	e3500000 	cmp	r0, #0                                        
    b84c:	0a000055 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   
      return 0;                                                       
                                                                      
    return &info->indirect[ my_block ];                               
    b850:	e0800106 	add	r0, r0, r6, lsl #2                            
    b854:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
    b858:	e2852001 	add	r2, r5, #1                                    <== NOT EXECUTED
    b85c:	e0030295 	mul	r3, r5, r2                                    <== NOT EXECUTED
    b860:	e2432001 	sub	r2, r3, #1                                    <== NOT EXECUTED
    b864:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    b868:	8a000015 	bhi	b8c4 <IMFS_memfile_get_block_pointer+0x104>   <== NOT EXECUTED
#if 0                                                                 
fprintf(stdout, "(d %d) ", block );                                   
fflush(stdout);                                                       
#endif                                                                
                                                                      
    my_block -= FIRST_DOUBLY_INDIRECT;                                
    b86c:	e0656001 	rsb	r6, r5, r1                                    <== NOT EXECUTED
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    b870:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    b874:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    b878:	eb002cef 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    b87c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
fflush(stdout);                                                       
#endif                                                                
                                                                      
    my_block -= FIRST_DOUBLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    b880:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    b884:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    b888:	eb002c57 	bl	169ec <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
    b88c:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
#endif                                                                
                                                                      
    my_block -= FIRST_DOUBLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    b890:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
    p = info->doubly_indirect;                                        
    b894:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    if ( malloc_it ) {                                                
    b898:	0a00003b 	beq	b98c <IMFS_memfile_get_block_pointer+0x1cc>   <== NOT EXECUTED
                                                                      
      if ( !p ) {                                                     
    b89c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    b8a0:	1a000003 	bne	b8b4 <IMFS_memfile_get_block_pointer+0xf4>    <== NOT EXECUTED
        p = memfile_alloc_block();                                    
    b8a4:	ebffffb8 	bl	b78c <memfile_alloc_block>                     <== NOT EXECUTED
        if ( !p )                                                     
    b8a8:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    b8ac:	0a00003d 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
           return 0;                                                  
        info->doubly_indirect = p;                                    
    b8b0:	e584305c 	str	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
    b8b4:	e7930105 	ldr	r0, [r3, r5, lsl #2]                          <== NOT EXECUTED
    b8b8:	e0835105 	add	r5, r3, r5, lsl #2                            <== NOT EXECUTED
      if ( !p1 ) {                                                    
    b8bc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    b8c0:	ea000028 	b	b968 <IMFS_memfile_get_block_pointer+0x1a8>     <== NOT EXECUTED
#endif                                                                
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
    b8c4:	e2831001 	add	r1, r3, #1                                    <== NOT EXECUTED
    b8c8:	e0020195 	mul	r2, r5, r1                                    <== NOT EXECUTED
    b8cc:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
    b8d0:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
    b8d4:	8a000033 	bhi	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
    my_block -= FIRST_TRIPLY_INDIRECT;                                
    b8d8:	e0636006 	rsb	r6, r3, r6                                    <== NOT EXECUTED
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    b8dc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    b8e0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    b8e4:	eb002cd4 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    b8e8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    b8ec:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    b8f0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    b8f4:	eb002c3c 	bl	169ec <__aeabi_uidiv>                          <== NOT EXECUTED
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
    b8f8:	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;                     
    b8fc:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
    b900:	eb002c39 	bl	169ec <__aeabi_uidiv>                          <== NOT EXECUTED
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
    b904:	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;                       
    b908:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
    b90c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    b910:	eb002cc9 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
    b914:	e3580000 	cmp	r8, #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;                               
    b918:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
    p = info->triply_indirect;                                        
    b91c:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
                                                                      
    if ( malloc_it ) {                                                
    b920:	0a000016 	beq	b980 <IMFS_memfile_get_block_pointer+0x1c0>   <== NOT EXECUTED
      if ( !p ) {                                                     
    b924:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    b928:	1a000003 	bne	b93c <IMFS_memfile_get_block_pointer+0x17c>   <== NOT EXECUTED
        p = memfile_alloc_block();                                    
    b92c:	ebffff96 	bl	b78c <memfile_alloc_block>                     <== NOT EXECUTED
        if ( !p )                                                     
    b930:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    b934:	0a00001b 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
           return 0;                                                  
        info->triply_indirect = p;                                    
    b938:	e5843060 	str	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
    b93c:	e7932107 	ldr	r2, [r3, r7, lsl #2]                          <== NOT EXECUTED
      if ( !p1 ) {                                                    
    b940:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        if ( !p )                                                     
           return 0;                                                  
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
    b944:	e0837107 	add	r7, r3, r7, lsl #2                            <== NOT EXECUTED
      if ( !p1 ) {                                                    
    b948:	1a000003 	bne	b95c <IMFS_memfile_get_block_pointer+0x19c>   <== NOT EXECUTED
        p1 = memfile_alloc_block();                                   
    b94c:	ebffff8e 	bl	b78c <memfile_alloc_block>                     <== NOT EXECUTED
        if ( !p1 )                                                    
    b950:	e2502000 	subs	r2, r0, #0                                   <== NOT EXECUTED
    b954:	0a000013 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
    b958:	e5872000 	str	r2, [r7]                                      <== NOT EXECUTED
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
    b95c:	e7920105 	ldr	r0, [r2, r5, lsl #2]                          <== NOT EXECUTED
    b960:	e0825105 	add	r5, r2, r5, lsl #2                            <== NOT EXECUTED
      if ( !p2 ) {                                                    
    b964:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    b968:	1a00000c 	bne	b9a0 <IMFS_memfile_get_block_pointer+0x1e0>   <== NOT EXECUTED
        p2 = memfile_alloc_block();                                   
    b96c:	ebffff86 	bl	b78c <memfile_alloc_block>                     <== NOT EXECUTED
        if ( !p2 )                                                    
    b970:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
    b974:	15850000 	strne	r0, [r5]                                    <== NOT EXECUTED
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
      if ( !p2 ) {                                                    
        p2 = memfile_alloc_block();                                   
        if ( !p2 )                                                    
    b978:	1a000008 	bne	b9a0 <IMFS_memfile_get_block_pointer+0x1e0>   <== NOT EXECUTED
    b97c:	ea000009 	b	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>     <== NOT EXECUTED
        p1[ doubly ] = (block_p) p2;                                  
      }                                                               
      return (block_p *)&p2[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
    b980:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    b984:	0a000007 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
                                                                      
#if 0                                                                 
fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly );
fflush(stdout);                                                       
#endif                                                                
    p1 = (block_p *) p[ triply ];                                     
    b988:	e7933107 	ldr	r3, [r3, r7, lsl #2]                          <== NOT EXECUTED
    if ( !p1 )                                                        
    b98c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    b990:	0a000004 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
    b994:	e7930105 	ldr	r0, [r3, r5, lsl #2]                          <== NOT EXECUTED
    if ( !p2 )                                                        
    b998:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    b99c:	0a000001 	beq	b9a8 <IMFS_memfile_get_block_pointer+0x1e8>   <== NOT EXECUTED
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
    b9a0:	e080010a 	add	r0, r0, sl, lsl #2                            <== NOT EXECUTED
    b9a4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    b9a8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
                                                                      
  return 0;                                                           
}                                                                     
    b9ac:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

0000c2cc <IMFS_memfile_read>: IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) {
    c2cc:	e92d4ff7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    c2d0:	e2504000 	subs	r4, r0, #0                                   
   IMFS_jnode_t    *the_jnode,                                        
   off_t            start,                                            
   unsigned char   *destination,                                      
   unsigned int     length                                            
)                                                                     
{                                                                     
    c2d4:	e1a06003 	mov	r6, r3                                        
    c2d8:	e1a08001 	mov	r8, r1                                        
    c2dc:	e1a09002 	mov	r9, r2                                        
    c2e0:	e59d7030 	ldr	r7, [sp, #48]	; 0x30                          
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    c2e4:	059f024c 	ldreq	r0, [pc, #588]	; c538 <IMFS_memfile_read+0x26c>
    c2e8:	03a01f93 	moveq	r1, #588	; 0x24c                            
    c2ec:	059f2248 	ldreq	r2, [pc, #584]	; c53c <IMFS_memfile_read+0x270>
    c2f0:	059f3248 	ldreq	r3, [pc, #584]	; c540 <IMFS_memfile_read+0x274>
    c2f4:	0a000007 	beq	c318 <IMFS_memfile_read+0x4c>                 
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE ||                      
    c2f8:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    c2fc:	e2432005 	sub	r2, r3, #5                                    
    c300:	e3520001 	cmp	r2, #1                                        
    c304:	9a000004 	bls	c31c <IMFS_memfile_read+0x50>                 
    c308:	e59f0228 	ldr	r0, [pc, #552]	; c538 <IMFS_memfile_read+0x26c><== NOT EXECUTED
    c30c:	e59f1230 	ldr	r1, [pc, #560]	; c544 <IMFS_memfile_read+0x278><== NOT EXECUTED
    c310:	e59f2224 	ldr	r2, [pc, #548]	; c53c <IMFS_memfile_read+0x270><== NOT EXECUTED
    c314:	e59f322c 	ldr	r3, [pc, #556]	; c548 <IMFS_memfile_read+0x27c><== NOT EXECUTED
    c318:	ebfff73b 	bl	a00c <__assert_func>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Error checks on arguments                                       
   */                                                                 
                                                                      
  assert( dest );                                                     
    c31c:	e3560000 	cmp	r6, #0                                        
    c320:	059f0210 	ldreq	r0, [pc, #528]	; c538 <IMFS_memfile_read+0x26c>
    c324:	059f1220 	ldreq	r1, [pc, #544]	; c54c <IMFS_memfile_read+0x280>
    c328:	059f220c 	ldreq	r2, [pc, #524]	; c53c <IMFS_memfile_read+0x270>
    c32c:	059f321c 	ldreq	r3, [pc, #540]	; c550 <IMFS_memfile_read+0x284>
    c330:	0afffff8 	beq	c318 <IMFS_memfile_read+0x4c>                 
  /*                                                                  
   *  If there is nothing to read, then quick exit.                   
   */                                                                 
                                                                      
  my_length = length;                                                 
  if ( !my_length )                                                   
    c334:	e3570000 	cmp	r7, #0                                        
    c338:	1a000004 	bne	c350 <IMFS_memfile_read+0x84>                 
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    c33c:	eb000420 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    c340:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    c344:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    c348:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
    c34c:	ea000077 	b	c530 <IMFS_memfile_read+0x264>                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    c350:	e3530006 	cmp	r3, #6                                        
    c354:	1a000012 	bne	c3a4 <IMFS_memfile_read+0xd8>                 
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
    c358:	e284b050 	add	fp, r4, #80	; 0x50                            <== NOT EXECUTED
    c35c:	e89b0c00 	ldm	fp, {sl, fp}                                  <== NOT EXECUTED
    c360:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
    c364:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
    c368:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    c36c:	e0522008 	subs	r2, r2, r8                                   <== NOT EXECUTED
    c370:	e0c33009 	sbc	r3, r3, r9                                    <== NOT EXECUTED
    c374:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
   *  than block files).                                              
   */                                                                 
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
    c378:	e5941058 	ldr	r1, [r4, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
    c37c:	ca000002 	bgt	c38c <IMFS_memfile_read+0xc0>                 <== NOT EXECUTED
    c380:	1a000002 	bne	c390 <IMFS_memfile_read+0xc4>                 <== NOT EXECUTED
    c384:	e1570002 	cmp	r7, r2                                        <== NOT EXECUTED
    c388:	9a000000 	bls	c390 <IMFS_memfile_read+0xc4>                 <== NOT EXECUTED
      my_length = the_jnode->info.linearfile.size - start;            
    c38c:	e068700a 	rsb	r7, r8, sl                                    <== NOT EXECUTED
                                                                      
    memcpy(dest, &file_ptr[start], my_length);                        
    c390:	e0811008 	add	r1, r1, r8                                    <== NOT EXECUTED
    c394:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    c398:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
    c39c:	eb000616 	bl	dbfc <memcpy>                                  <== NOT EXECUTED
    c3a0:	ea00005d 	b	c51c <IMFS_memfile_read+0x250>                  <== 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 )                        
    c3a4:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          
    c3a8:	e3a02000 	mov	r2, #0                                        
    c3ac:	e1520003 	cmp	r2, r3                                        
    c3b0:	e5945050 	ldr	r5, [r4, #80]	; 0x50                          
  /*                                                                  
   *  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;                                         
    c3b4:	e1a03001 	mov	r3, r1                                        
  if ( last_byte > the_jnode->info.file.size )                        
    c3b8:	e0872001 	add	r2, r7, r1                                    
    c3bc:	ca000004 	bgt	c3d4 <IMFS_memfile_read+0x108>                
    c3c0:	1a000001 	bne	c3cc <IMFS_memfile_read+0x100>                
    c3c4:	e1520005 	cmp	r2, r5                                        
    c3c8:	8a000001 	bhi	c3d4 <IMFS_memfile_read+0x108>                
    c3cc:	e1a05007 	mov	r5, r7                                        
    c3d0:	ea000000 	b	c3d8 <IMFS_memfile_read+0x10c>                  
    my_length = the_jnode->info.file.size - start;                    
    c3d4:	e0635005 	rsb	r5, r3, r5                                    
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
    c3d8:	e59f3174 	ldr	r3, [pc, #372]	; c554 <IMFS_memfile_read+0x288>
    c3dc:	e593a000 	ldr	sl, [r3]                                      
    c3e0:	e1a0b00a 	mov	fp, sl                                        
    c3e4:	e1a0cfcb 	asr	ip, fp, #31                                   
    c3e8:	e1a0300c 	mov	r3, ip                                        
    c3ec:	e1a00008 	mov	r0, r8                                        
    c3f0:	e1a0200b 	mov	r2, fp                                        
    c3f4:	e1a01009 	mov	r1, r9                                        
    c3f8:	e58dc000 	str	ip, [sp]                                      
    c3fc:	eb002de5 	bl	17b98 <__moddi3>                               
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
    c400:	e59dc000 	ldr	ip, [sp]                                      
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
    c404:	e1a07000 	mov	r7, r0                                        
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
    c408:	e1a01009 	mov	r1, r9                                        
    c40c:	e1a00008 	mov	r0, r8                                        
    c410:	e1a0200b 	mov	r2, fp                                        
    c414:	e1a0300c 	mov	r3, ip                                        
    c418:	eb002cb4 	bl	176f0 <__divdi3>                               
  if ( start_offset )  {                                              
    c41c:	e3570000 	cmp	r7, #0                                        
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
    c420:	e1a08000 	mov	r8, r0                                        
  if ( start_offset )  {                                              
    c424:	0a000013 	beq	c478 <IMFS_memfile_read+0x1ac>                
    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 );
    c428:	e1a00004 	mov	r0, r4                                        
    c42c:	e1a01008 	mov	r1, r8                                        
    c430:	e3a02000 	mov	r2, #0                                        
    c434:	ebfffce1 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
    assert( block_ptr );                                              
    c438:	e3500000 	cmp	r0, #0                                        
    c43c:	059f00f4 	ldreq	r0, [pc, #244]	; c538 <IMFS_memfile_read+0x26c>
    c440:	059f1110 	ldreq	r1, [pc, #272]	; c558 <IMFS_memfile_read+0x28c>
    c444:	0a00002c 	beq	c4fc <IMFS_memfile_read+0x230>                
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
    c448:	e5901000 	ldr	r1, [r0]                                      
   */                                                                 
                                                                      
  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;            
    c44c:	e067a00a 	rsb	sl, r7, sl                                    
    c450:	e155000a 	cmp	r5, sl                                        
    c454:	31a0a005 	movcc	sl, r5                                      
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    assert( block_ptr );                                              
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
    c458:	e0811007 	add	r1, r1, r7                                    
    c45c:	e1a00006 	mov	r0, r6                                        
    c460:	e1a0200a 	mov	r2, sl                                        
    c464:	eb0005e4 	bl	dbfc <memcpy>                                  
    dest += to_copy;                                                  
    c468:	e086600a 	add	r6, r6, sl                                    
    block++;                                                          
    c46c:	e2888001 	add	r8, r8, #1                                    
    my_length -= to_copy;                                             
    c470:	e06a5005 	rsb	r5, sl, r5                                    
    c474:	e1a0700a 	mov	r7, sl                                        
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
    c478:	e59f30d4 	ldr	r3, [pc, #212]	; c554 <IMFS_memfile_read+0x288>
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    c47c:	e1a09003 	mov	r9, r3                                        
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
    c480:	e593a000 	ldr	sl, [r3]                                      
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    c484:	ea00000f 	b	c4c8 <IMFS_memfile_read+0x1fc>                  
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    c488:	e1a00004 	mov	r0, r4                                        
    c48c:	e1a01008 	mov	r1, r8                                        
    c490:	e3a02000 	mov	r2, #0                                        
    c494:	ebfffcc9 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
    assert( block_ptr );                                              
    c498:	e3500000 	cmp	r0, #0                                        
    c49c:	059f0094 	ldreq	r0, [pc, #148]	; c538 <IMFS_memfile_read+0x26c>
    c4a0:	059f10b4 	ldreq	r1, [pc, #180]	; c55c <IMFS_memfile_read+0x290>
    c4a4:	0a000014 	beq	c4fc <IMFS_memfile_read+0x230>                
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
    c4a8:	e5901000 	ldr	r1, [r0]                                      
    c4ac:	e1a0200a 	mov	r2, sl                                        
    c4b0:	e1a00006 	mov	r0, r6                                        
    c4b4:	eb0005d0 	bl	dbfc <memcpy>                                  
    dest += to_copy;                                                  
    c4b8:	e086600a 	add	r6, r6, sl                                    
    block++;                                                          
    c4bc:	e2888001 	add	r8, r8, #1                                    
    my_length -= to_copy;                                             
    c4c0:	e06a5005 	rsb	r5, sl, r5                                    
    copied += to_copy;                                                
    c4c4:	e087700a 	add	r7, r7, sl                                    
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    c4c8:	e5993000 	ldr	r3, [r9]                                      
    c4cc:	e1550003 	cmp	r5, r3                                        
    c4d0:	2affffec 	bcs	c488 <IMFS_memfile_read+0x1bc>                
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
                                                                      
  assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );                 
                                                                      
  if ( my_length ) {                                                  
    c4d4:	e3550000 	cmp	r5, #0                                        
    c4d8:	0a00000f 	beq	c51c <IMFS_memfile_read+0x250>                
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    c4dc:	e1a01008 	mov	r1, r8                                        
    c4e0:	e1a00004 	mov	r0, r4                                        
    c4e4:	e3a02000 	mov	r2, #0                                        
    c4e8:	ebfffcb4 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
    assert( block_ptr );                                              
    c4ec:	e2503000 	subs	r3, r0, #0                                   
    c4f0:	1a000004 	bne	c508 <IMFS_memfile_read+0x23c>                
    c4f4:	e59f003c 	ldr	r0, [pc, #60]	; c538 <IMFS_memfile_read+0x26c><== NOT EXECUTED
    c4f8:	e59f1060 	ldr	r1, [pc, #96]	; c560 <IMFS_memfile_read+0x294><== NOT EXECUTED
    c4fc:	e59f2038 	ldr	r2, [pc, #56]	; c53c <IMFS_memfile_read+0x270><== NOT EXECUTED
    c500:	e59f305c 	ldr	r3, [pc, #92]	; c564 <IMFS_memfile_read+0x298><== NOT EXECUTED
    c504:	eaffff83 	b	c318 <IMFS_memfile_read+0x4c>                   <== NOT EXECUTED
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
    c508:	e1a00006 	mov	r0, r6                                        
    c50c:	e5931000 	ldr	r1, [r3]                                      
    c510:	e1a02005 	mov	r2, r5                                        
    c514:	eb0005b8 	bl	dbfc <memcpy>                                  
    copied += my_length;                                              
    c518:	e0857007 	add	r7, r5, r7                                    
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
    c51c:	e28d0004 	add	r0, sp, #4                                    
    c520:	e3a01000 	mov	r1, #0                                        
    c524:	ebffd692 	bl	1f74 <gettimeofday>                            
    c528:	e59d3004 	ldr	r3, [sp, #4]                                  
    c52c:	e5843040 	str	r3, [r4, #64]	; 0x40                          
                                                                      
  return copied;                                                      
}                                                                     
    c530:	e1a00007 	mov	r0, r7                                        
    c534:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
                                                                      

0000ba8c <IMFS_memfile_remove>: */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) {
    ba8c:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    ba90:	e2504000 	subs	r4, r0, #0                                   
    ba94:	059f012c 	ldreq	r0, [pc, #300]	; bbc8 <IMFS_memfile_remove+0x13c>
    ba98:	059f112c 	ldreq	r1, [pc, #300]	; bbcc <IMFS_memfile_remove+0x140>
    ba9c:	059f212c 	ldreq	r2, [pc, #300]	; bbd0 <IMFS_memfile_remove+0x144>
    baa0:	059f312c 	ldreq	r3, [pc, #300]	; bbd4 <IMFS_memfile_remove+0x148>
    baa4:	0a000006 	beq	bac4 <IMFS_memfile_remove+0x38>               
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
    baa8:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    baac:	e3530005 	cmp	r3, #5                                        
    bab0:	0a000004 	beq	bac8 <IMFS_memfile_remove+0x3c>               
    bab4:	e59f010c 	ldr	r0, [pc, #268]	; bbc8 <IMFS_memfile_remove+0x13c><== NOT EXECUTED
    bab8:	e59f1118 	ldr	r1, [pc, #280]	; bbd8 <IMFS_memfile_remove+0x14c><== NOT EXECUTED
    babc:	e59f210c 	ldr	r2, [pc, #268]	; bbd0 <IMFS_memfile_remove+0x144><== NOT EXECUTED
    bac0:	e59f3114 	ldr	r3, [pc, #276]	; bbdc <IMFS_memfile_remove+0x150><== NOT EXECUTED
    bac4:	ebfff950 	bl	a00c <__assert_func>                           <== 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;                                 
    bac8:	e59f2110 	ldr	r2, [pc, #272]	; bbe0 <IMFS_memfile_remove+0x154>
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    bacc:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          
  /*                                                                  
   *  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;                                 
    bad0:	e5925000 	ldr	r5, [r2]                                      
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    bad4:	e3530000 	cmp	r3, #0                                        
  /*                                                                  
   *  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;                                 
    bad8:	e1a05125 	lsr	r5, r5, #2                                    
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
    memfile_free_blocks_in_table( &info->indirect, to_free );         
    badc:	12840058 	addne	r0, r4, #88	; 0x58                          
    bae0:	11a01005 	movne	r1, r5                                      
    bae4:	1bffffb6 	blne	b9c4 <memfile_free_blocks_in_table>          
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    bae8:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          
    baec:	e3530000 	cmp	r3, #0                                        
    baf0:	13a06000 	movne	r6, #0                                      
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
                                                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
    baf4:	159f70e4 	ldrne	r7, [pc, #228]	; bbe0 <IMFS_memfile_remove+0x154>
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    baf8:	1a000008 	bne	bb20 <IMFS_memfile_remove+0x94>               
    bafc:	ea00000d 	b	bb38 <IMFS_memfile_remove+0xac>                 
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
                                                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      if ( info->doubly_indirect[i] ) {                               
    bb00:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    bb04:	e7932106 	ldr	r2, [r3, r6, lsl #2]                          <== NOT EXECUTED
    bb08:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    bb0c:	e1a00106 	lsl	r0, r6, #2                                    <== NOT EXECUTED
        memfile_free_blocks_in_table(                                 
    bb10:	10830000 	addne	r0, r3, r0                                  <== NOT EXECUTED
    bb14:	11a01005 	movne	r1, r5                                      <== NOT EXECUTED
    bb18:	1bffffa9 	blne	b9c4 <memfile_free_blocks_in_table>          <== NOT EXECUTED
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
                                                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
    bb1c:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
    bb20:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
    bb24:	e1560123 	cmp	r6, r3, lsr #2                                <== NOT EXECUTED
    bb28:	3afffff4 	bcc	bb00 <IMFS_memfile_remove+0x74>               <== 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 );  
    bb2c:	e284005c 	add	r0, r4, #92	; 0x5c                            <== NOT EXECUTED
    bb30:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    bb34:	ebffffa2 	bl	b9c4 <memfile_free_blocks_in_table>            <== NOT EXECUTED
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    bb38:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          
    bb3c:	e3530000 	cmp	r3, #0                                        
    bb40:	13a06000 	movne	r6, #0                                      
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
    bb44:	159fa094 	ldrne	sl, [pc, #148]	; bbe0 <IMFS_memfile_remove+0x154>
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    bb48:	1a000016 	bne	bba8 <IMFS_memfile_remove+0x11c>              
    bb4c:	ea00001b 	b	bbc0 <IMFS_memfile_remove+0x134>                
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
    bb50:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
    bb54:	e7937106 	ldr	r7, [r3, r6, lsl #2]                          <== NOT EXECUTED
      if ( !p )  /* ensure we have a valid pointer */                 
    bb58:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   *    + indirect                                                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
                                                                      
  info = &the_jnode->info.file;                                       
    bb5c:	e1a09106 	lsl	r9, r6, #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 */                 
    bb60:	0a000013 	beq	bbb4 <IMFS_memfile_remove+0x128>              <== NOT EXECUTED
    bb64:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
    bb68:	ea000006 	b	bb88 <IMFS_memfile_remove+0xfc>                 <== NOT EXECUTED
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
        if ( p[j] ) {                                                 
    bb6c:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
    bb70:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
    bb74:	11a00007 	movne	r0, r7                                      <== NOT EXECUTED
    bb78:	11a01005 	movne	r1, r5                                      <== NOT EXECUTED
    bb7c:	1bffff90 	blne	b9c4 <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++ ) {                
    bb80:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
    bb84:	e2877004 	add	r7, r7, #4                                    <== NOT EXECUTED
    bb88:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
    bb8c:	e1580123 	cmp	r8, r3, lsr #2                                <== NOT EXECUTED
    bb90:	3afffff5 	bcc	bb6c <IMFS_memfile_remove+0xe0>               <== NOT EXECUTED
        if ( p[j] ) {                                                 
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
    bb94:	e5940060 	ldr	r0, [r4, #96]	; 0x60                          <== NOT EXECUTED
    bb98:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    bb9c:	e0800009 	add	r0, r0, r9                                    <== NOT EXECUTED
    bba0:	ebffff87 	bl	b9c4 <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++ ) {                  
    bba4:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
    bba8:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
    bbac:	e1560123 	cmp	r6, r3, lsr #2                                <== NOT EXECUTED
    bbb0:	3affffe6 	bcc	bb50 <IMFS_memfile_remove+0xc4>               <== NOT EXECUTED
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
        (block_p **)&info->triply_indirect[i], to_free );             
    }                                                                 
    memfile_free_blocks_in_table(                                     
    bbb4:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
    bbb8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    bbbc:	ebffff80 	bl	b9c4 <memfile_free_blocks_in_table>            <== NOT EXECUTED
        (block_p **)&info->triply_indirect, to_free );                
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
    bbc0:	e3a00000 	mov	r0, #0                                        
    bbc4:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
                                                                      

0000ba40 <IMFS_memfile_remove_block>: MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) {
    ba40:	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 );  
    ba44:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    ba48:	ebffff5c 	bl	b7c0 <IMFS_memfile_get_block_pointer>          <== NOT EXECUTED
  assert( block_ptr );                                                
    ba4c:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    ba50:	059f0024 	ldreq	r0, [pc, #36]	; ba7c <IMFS_memfile_remove_block+0x3c><== NOT EXECUTED
    ba54:	059f1024 	ldreq	r1, [pc, #36]	; ba80 <IMFS_memfile_remove_block+0x40><== NOT EXECUTED
    ba58:	059f2024 	ldreq	r2, [pc, #36]	; ba84 <IMFS_memfile_remove_block+0x44><== NOT EXECUTED
    ba5c:	059f3024 	ldreq	r3, [pc, #36]	; ba88 <IMFS_memfile_remove_block+0x48><== NOT EXECUTED
    ba60:	0bfff969 	bleq	a00c <__assert_func>                         <== NOT EXECUTED
  if ( block_ptr ) {                                                  
    ptr = *block_ptr;                                                 
    *block_ptr = 0;                                                   
    ba64:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
  block_p  ptr;                                                       
                                                                      
  block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );  
  assert( block_ptr );                                                
  if ( block_ptr ) {                                                  
    ptr = *block_ptr;                                                 
    ba68:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    *block_ptr = 0;                                                   
    ba6c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    memfile_free_block( ptr );                                        
    ba70:	ebffff3d 	bl	b76c <memfile_free_block>                      <== NOT EXECUTED
  }                                                                   
                                                                      
  return 1;                                                           
}                                                                     
    ba74:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    ba78:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

0000bf9c <IMFS_memfile_write>: IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) {
    bf9c:	e92d4ff7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    bfa0:	e2504000 	subs	r4, r0, #0                                   
   IMFS_jnode_t          *the_jnode,                                  
   off_t                  start,                                      
   const unsigned char   *source,                                     
   unsigned int           length                                      
)                                                                     
{                                                                     
    bfa4:	e1a08001 	mov	r8, r1                                        
    bfa8:	e1a0a002 	mov	sl, r2                                        
    bfac:	e1a06003 	mov	r6, r3                                        
    bfb0:	e59d5030 	ldr	r5, [sp, #48]	; 0x30                          
                                                                      
  /*                                                                  
   *  Perform internal consistency checks                             
   */                                                                 
                                                                      
  assert( the_jnode );                                                
    bfb4:	059f0204 	ldreq	r0, [pc, #516]	; c1c0 <IMFS_memfile_write+0x224>
    bfb8:	059f1204 	ldreq	r1, [pc, #516]	; c1c4 <IMFS_memfile_write+0x228>
    bfbc:	059f2204 	ldreq	r2, [pc, #516]	; c1c8 <IMFS_memfile_write+0x22c>
    bfc0:	059f3204 	ldreq	r3, [pc, #516]	; c1cc <IMFS_memfile_write+0x230>
    bfc4:	0a000006 	beq	bfe4 <IMFS_memfile_write+0x48>                
  if ( !the_jnode )                                                   
    rtems_set_errno_and_return_minus_one( EIO );                      
                                                                      
  assert( the_jnode->type == IMFS_MEMORY_FILE );                      
    bfc8:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    bfcc:	e3530005 	cmp	r3, #5                                        
    bfd0:	0a000004 	beq	bfe8 <IMFS_memfile_write+0x4c>                
    bfd4:	e59f01e4 	ldr	r0, [pc, #484]	; c1c0 <IMFS_memfile_write+0x224><== NOT EXECUTED
    bfd8:	e59f11f0 	ldr	r1, [pc, #496]	; c1d0 <IMFS_memfile_write+0x234><== NOT EXECUTED
    bfdc:	e59f21e4 	ldr	r2, [pc, #484]	; c1c8 <IMFS_memfile_write+0x22c><== NOT EXECUTED
    bfe0:	e59f31ec 	ldr	r3, [pc, #492]	; c1d4 <IMFS_memfile_write+0x238><== NOT EXECUTED
    bfe4:	ebfff808 	bl	a00c <__assert_func>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Error check arguments                                           
   */                                                                 
                                                                      
  assert( source );                                                   
    bfe8:	e3560000 	cmp	r6, #0                                        
    bfec:	059f01cc 	ldreq	r0, [pc, #460]	; c1c0 <IMFS_memfile_write+0x224>
    bff0:	059f11e0 	ldreq	r1, [pc, #480]	; c1d8 <IMFS_memfile_write+0x23c>
    bff4:	059f21cc 	ldreq	r2, [pc, #460]	; c1c8 <IMFS_memfile_write+0x22c>
    bff8:	059f31dc 	ldreq	r3, [pc, #476]	; c1dc <IMFS_memfile_write+0x240>
    bffc:	0afffff8 	beq	bfe4 <IMFS_memfile_write+0x48>                
  /*                                                                  
   *  If there is nothing to write, then quick exit.                  
   */                                                                 
                                                                      
  my_length = length;                                                 
  if ( !my_length )                                                   
    c000:	e3550000 	cmp	r5, #0                                        
    c004:	1a000002 	bne	c014 <IMFS_memfile_write+0x78>                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    c008:	eb0004ed 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    c00c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    c010:	ea00000e 	b	c050 <IMFS_memfile_write+0xb4>                  <== 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 + length;                                         
  if ( last_byte > the_jnode->info.file.size ) {                      
    c014:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          
    c018:	e3530000 	cmp	r3, #0                                        
    c01c:	e0851001 	add	r1, r5, r1                                    
    c020:	ba000003 	blt	c034 <IMFS_memfile_write+0x98>                
    c024:	1a00000c 	bne	c05c <IMFS_memfile_write+0xc0>                
    c028:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          
    c02c:	e1530001 	cmp	r3, r1                                        
    c030:	2a000009 	bcs	c05c <IMFS_memfile_write+0xc0>                
    status = IMFS_memfile_extend( the_jnode, last_byte );             
    c034:	e1a00004 	mov	r0, r4                                        
    c038:	e3a02000 	mov	r2, #0                                        
    c03c:	ebffff40 	bl	bd44 <IMFS_memfile_extend>                     
    if ( status )                                                     
    c040:	e3500000 	cmp	r0, #0                                        
    c044:	0a000004 	beq	c05c <IMFS_memfile_write+0xc0>                
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
    c048:	eb0004dd 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    c04c:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
    c050:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    c054:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
    c058:	ea000056 	b	c1b8 <IMFS_memfile_write+0x21c>                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
    c05c:	e59f317c 	ldr	r3, [pc, #380]	; c1e0 <IMFS_memfile_write+0x244>
    c060:	e5939000 	ldr	r9, [r3]                                      
    c064:	e1a0b009 	mov	fp, r9                                        
    c068:	e1a0cfcb 	asr	ip, fp, #31                                   
    c06c:	e1a0300c 	mov	r3, ip                                        
    c070:	e1a00008 	mov	r0, r8                                        
    c074:	e1a0200b 	mov	r2, fp                                        
    c078:	e1a0100a 	mov	r1, sl                                        
    c07c:	e58dc000 	str	ip, [sp]                                      
    c080:	eb002ec4 	bl	17b98 <__moddi3>                               
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
    c084:	e59dc000 	ldr	ip, [sp]                                      
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
    c088:	e1a07000 	mov	r7, r0                                        
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
    c08c:	e1a0100a 	mov	r1, sl                                        
    c090:	e1a00008 	mov	r0, r8                                        
    c094:	e1a0200b 	mov	r2, fp                                        
    c098:	e1a0300c 	mov	r3, ip                                        
    c09c:	eb002d93 	bl	176f0 <__divdi3>                               
  if ( start_offset )  {                                              
    c0a0:	e3570000 	cmp	r7, #0                                        
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
                                                                      
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
    c0a4:	e1a08000 	mov	r8, r0                                        
  if ( start_offset )  {                                              
    c0a8:	0a000013 	beq	c0fc <IMFS_memfile_write+0x160>               
    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 );
    c0ac:	e1a01008 	mov	r1, r8                                        
    c0b0:	e1a00004 	mov	r0, r4                                        
    c0b4:	e3a02000 	mov	r2, #0                                        
    c0b8:	ebfffdc0 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
    assert( block_ptr );                                              
    c0bc:	e3500000 	cmp	r0, #0                                        
    c0c0:	059f00f8 	ldreq	r0, [pc, #248]	; c1c0 <IMFS_memfile_write+0x224>
    c0c4:	03a01fc7 	moveq	r1, #796	; 0x31c                            
    c0c8:	0a00002c 	beq	c180 <IMFS_memfile_write+0x1e4>               
    if ( !block_ptr )                                                 
      return copied;                                                  
#if 0                                                                 
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif                                                                
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
    c0cc:	e5900000 	ldr	r0, [r0]                                      
   */                                                                 
                                                                      
  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;            
    c0d0:	e067a009 	rsb	sl, r7, r9                                    
    c0d4:	e15a0005 	cmp	sl, r5                                        
    c0d8:	21a0a005 	movcs	sl, r5                                      
    if ( !block_ptr )                                                 
      return copied;                                                  
#if 0                                                                 
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif                                                                
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
    c0dc:	e0800007 	add	r0, r0, r7                                    
    c0e0:	e1a01006 	mov	r1, r6                                        
    c0e4:	e1a0200a 	mov	r2, sl                                        
    c0e8:	eb0006c3 	bl	dbfc <memcpy>                                  
    src += to_copy;                                                   
    c0ec:	e086600a 	add	r6, r6, sl                                    
    block++;                                                          
    c0f0:	e2888001 	add	r8, r8, #1                                    
    my_length -= to_copy;                                             
    c0f4:	e06a5005 	rsb	r5, sl, r5                                    
    copied += to_copy;                                                
    c0f8:	e1a0700a 	mov	r7, sl                                        
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
    c0fc:	e59f30dc 	ldr	r3, [pc, #220]	; c1e0 <IMFS_memfile_write+0x244>
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    c100:	e1a09003 	mov	r9, r3                                        
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
    c104:	e593a000 	ldr	sl, [r3]                                      
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    c108:	ea00000f 	b	c14c <IMFS_memfile_write+0x1b0>                 
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    c10c:	e1a00004 	mov	r0, r4                                        
    c110:	e1a01008 	mov	r1, r8                                        
    c114:	e3a02000 	mov	r2, #0                                        
    c118:	ebfffda8 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
    assert( block_ptr );                                              
    c11c:	e3500000 	cmp	r0, #0                                        
    c120:	059f0098 	ldreq	r0, [pc, #152]	; c1c0 <IMFS_memfile_write+0x224>
    c124:	03a01e33 	moveq	r1, #816	; 0x330                            
    c128:	0a000014 	beq	c180 <IMFS_memfile_write+0x1e4>               
    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 );                       
    c12c:	e1a01006 	mov	r1, r6                                        
    c130:	e5900000 	ldr	r0, [r0]                                      
    c134:	e1a0200a 	mov	r2, sl                                        
    c138:	eb0006af 	bl	dbfc <memcpy>                                  
    src += to_copy;                                                   
    c13c:	e086600a 	add	r6, r6, sl                                    
    block++;                                                          
    c140:	e2888001 	add	r8, r8, #1                                    
    my_length -= to_copy;                                             
    c144:	e06a5005 	rsb	r5, sl, r5                                    
 *                                                                    
 *  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(                            
    c148:	e087700a 	add	r7, r7, sl                                    
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    c14c:	e5993000 	ldr	r3, [r9]                                      
    c150:	e1550003 	cmp	r5, r3                                        
    c154:	2affffec 	bcs	c10c <IMFS_memfile_write+0x170>               
   */                                                                 
                                                                      
  assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );                 
                                                                      
  to_copy = my_length;                                                
  if ( my_length ) {                                                  
    c158:	e3550000 	cmp	r5, #0                                        
    c15c:	0a00000f 	beq	c1a0 <IMFS_memfile_write+0x204>               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    c160:	e1a01008 	mov	r1, r8                                        
    c164:	e1a00004 	mov	r0, r4                                        
    c168:	e3a02000 	mov	r2, #0                                        
    c16c:	ebfffd93 	bl	b7c0 <IMFS_memfile_get_block_pointer>          
    assert( block_ptr );                                              
    c170:	e3500000 	cmp	r0, #0                                        
    c174:	1a000004 	bne	c18c <IMFS_memfile_write+0x1f0>               
    c178:	e59f0040 	ldr	r0, [pc, #64]	; c1c0 <IMFS_memfile_write+0x224><== NOT EXECUTED
    c17c:	e59f1060 	ldr	r1, [pc, #96]	; c1e4 <IMFS_memfile_write+0x248><== NOT EXECUTED
    c180:	e59f2040 	ldr	r2, [pc, #64]	; c1c8 <IMFS_memfile_write+0x22c><== NOT EXECUTED
    c184:	e59f305c 	ldr	r3, [pc, #92]	; c1e8 <IMFS_memfile_write+0x24c><== NOT EXECUTED
    c188:	eaffff95 	b	bfe4 <IMFS_memfile_write+0x48>                  <== 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, my_length );                     
    c18c:	e5900000 	ldr	r0, [r0]                                      
    c190:	e1a01006 	mov	r1, r6                                        
    c194:	e1a02005 	mov	r2, r5                                        
    c198:	eb000697 	bl	dbfc <memcpy>                                  
    my_length = 0;                                                    
    copied += to_copy;                                                
    c19c:	e0877005 	add	r7, r7, r5                                    
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
    c1a0:	e28d0004 	add	r0, sp, #4                                    
    c1a4:	e3a01000 	mov	r1, #0                                        
    c1a8:	ebffd771 	bl	1f74 <gettimeofday>                            
    c1ac:	e59d3004 	ldr	r3, [sp, #4]                                  
    c1b0:	e5843048 	str	r3, [r4, #72]	; 0x48                          
    c1b4:	e5843044 	str	r3, [r4, #68]	; 0x44                          
                                                                      
  return copied;                                                      
}                                                                     
    c1b8:	e1a00007 	mov	r0, r7                                        
    c1bc:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
                                                                      

000016f0 <IMFS_mknod>: const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) {
    16f0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
    16f4:	e24dd040 	sub	sp, sp, #64	; 0x40                            
    16f8:	e1a04001 	mov	r4, r1                                        
    16fc:	e1a07000 	mov	r7, r0                                        
    1700:	e1a06002 	mov	r6, r2                                        
    1704:	e1a05003 	mov	r5, 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 );        
    1708:	eb003332 	bl	e3d8 <strlen>                                  
    170c:	e28d303c 	add	r3, sp, #60	; 0x3c                            
    1710:	e1a01000 	mov	r1, r0                                        
    1714:	e28d2004 	add	r2, sp, #4                                    
    1718:	e1a00007 	mov	r0, r7                                        
    171c:	eb00219f 	bl	9da0 <IMFS_get_token>                          
                                                                      
  /*                                                                  
   *  Figure out what type of IMFS node this is.                      
   */                                                                 
  if ( S_ISDIR(mode) )                                                
    1720:	e2043a0f 	and	r3, r4, #61440	; 0xf000                       
    1724:	e3530901 	cmp	r3, #16384	; 0x4000                           
    1728:	0a00000e 	beq	1768 <IMFS_mknod+0x78>                        
    type = IMFS_DIRECTORY;                                            
  else if ( S_ISREG(mode) )                                           
    172c:	e3530902 	cmp	r3, #32768	; 0x8000                           
    1730:	03a01005 	moveq	r1, #5                                      
    1734:	0a00000c 	beq	176c <IMFS_mknod+0x7c>                        
    type = IMFS_MEMORY_FILE;                                          
  else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {                        
    1738:	e3530a06 	cmp	r3, #24576	; 0x6000                           
    173c:	13530a02 	cmpne	r3, #8192	; 0x2000                          
    type = IMFS_DEVICE;                                               
    rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
    1740:	058d6028 	streq	r6, [sp, #40]	; 0x28                        
    1744:	058d502c 	streq	r5, [sp, #44]	; 0x2c                        
    1748:	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) ) {                        
    174c:	0a000006 	beq	176c <IMFS_mknod+0x7c>                        
    type = IMFS_DEVICE;                                               
    rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
  }                                                                   
  else if (S_ISFIFO(mode))                                            
    1750:	e3530a01 	cmp	r3, #4096	; 0x1000                            
    1754:	03a01007 	moveq	r1, #7                                      
    1758:	0a000003 	beq	176c <IMFS_mknod+0x7c>                        
    type = IMFS_FIFO;                                                 
  else  {                                                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    175c:	eb002f18 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1760:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    1764:	ea00000b 	b	1798 <IMFS_mknod+0xa8>                          <== NOT EXECUTED
    1768:	e3a01001 	mov	r1, #1                                        
   *        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(                                        
    176c:	e28dc028 	add	ip, sp, #40	; 0x28                            
    1770:	e59d0054 	ldr	r0, [sp, #84]	; 0x54                          
    1774:	e1a03004 	mov	r3, r4                                        
    1778:	e28d2004 	add	r2, sp, #4                                    
    177c:	e58dc000 	str	ip, [sp]                                      
    1780:	eb001e51 	bl	90cc <IMFS_create_node>                        
    new_name,                                                         
    mode,                                                             
    &info                                                             
  );                                                                  
                                                                      
  if ( !new_node )                                                    
    1784:	e3500000 	cmp	r0, #0                                        
    1788:	13a00000 	movne	r0, #0                                      
    178c:	1a000003 	bne	17a0 <IMFS_mknod+0xb0>                        
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
    1790:	eb002f0b 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1794:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    1798:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    179c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
    17a0:	e28dd040 	add	sp, sp, #64	; 0x40                            
    17a4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

000017a8 <IMFS_mount>: rtems_filesystem_mount_table_entry_t *mt_entry ) { IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access;
    17a8:	e5903008 	ldr	r3, [r0, #8]                                  
                                                                      
  /*                                                                  
   *  Is the node that we are mounting onto a directory node ?        
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
    17ac:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          
    17b0:	e3520001 	cmp	r2, #1                                        
#include <rtems/seterr.h>                                             
                                                                      
int IMFS_mount(                                                       
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
    17b4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
                                                                      
  /*                                                                  
   *  Is the node that we are mounting onto a directory node ?        
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
    17b8:	0a000004 	beq	17d0 <IMFS_mount+0x28>                        
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
    17bc:	eb002f00 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    17c0:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
    17c4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    17c8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    17cc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== 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;                              
    17d0:	e583005c 	str	r0, [r3, #92]	; 0x5c                          
    17d4:	e3a00000 	mov	r0, #0                                        
  return 0;                                                           
}                                                                     
    17d8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

00003cc0 <IMFS_print_jnode>: */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) {
    3cc0:	e92d4030 	push	{r4, r5, lr}                                 
  assert( the_jnode );                                                
    3cc4:	e2504000 	subs	r4, r0, #0                                   
    3cc8:	059f0130 	ldreq	r0, [pc, #304]	; 3e00 <IMFS_print_jnode+0x140>
    3ccc:	03a01038 	moveq	r1, #56	; 0x38                              
    3cd0:	059f212c 	ldreq	r2, [pc, #300]	; 3e04 <IMFS_print_jnode+0x144>
    3cd4:	059f312c 	ldreq	r3, [pc, #300]	; 3e08 <IMFS_print_jnode+0x148>
    3cd8:	0a00002f 	beq	3d9c <IMFS_print_jnode+0xdc>                  
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
    3cdc:	e59f5128 	ldr	r5, [pc, #296]	; 3e0c <IMFS_print_jnode+0x14c>
    3ce0:	e5953000 	ldr	r3, [r5]                                      
    3ce4:	e284000c 	add	r0, r4, #12                                   
    3ce8:	e5931008 	ldr	r1, [r3, #8]                                  
    3cec:	eb003745 	bl	11a08 <fputs>                                  
  switch( the_jnode->type ) {                                         
    3cf0:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          
    3cf4:	e2423001 	sub	r3, r2, #1                                    
    3cf8:	e3530006 	cmp	r3, #6                                        
    3cfc:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
    3d00:	ea000034 	b	3dd8 <IMFS_print_jnode+0x118>                   <== NOT EXECUTED
    3d04:	00003d20 	.word	0x00003d20                                  <== NOT EXECUTED
    3d08:	00003d34 	.word	0x00003d34                                  <== NOT EXECUTED
    3d0c:	00003d7c 	.word	0x00003d7c                                  <== NOT EXECUTED
    3d10:	00003da0 	.word	0x00003da0                                  <== NOT EXECUTED
    3d14:	00003d64 	.word	0x00003d64                                  <== NOT EXECUTED
    3d18:	00003d48 	.word	0x00003d48                                  <== NOT EXECUTED
    3d1c:	00003dbc 	.word	0x00003dbc                                  <== NOT EXECUTED
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
    3d20:	e5953000 	ldr	r3, [r5]                                      
    3d24:	e3a0002f 	mov	r0, #47	; 0x2f                                
    3d28:	e5931008 	ldr	r1, [r3, #8]                                  
    3d2c:	eb0036f0 	bl	118f4 <fputc>                                  
      break;                                                          
    3d30:	ea00002f 	b	3df4 <IMFS_print_jnode+0x134>                   
                                                                      
    case IMFS_DEVICE:                                                 
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
    3d34:	e5952000 	ldr	r2, [r5]                                      
    3d38:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          
    3d3c:	e5920008 	ldr	r0, [r2, #8]                                  
    3d40:	e59f10c8 	ldr	r1, [pc, #200]	; 3e10 <IMFS_print_jnode+0x150>
    3d44:	ea000003 	b	3d58 <IMFS_print_jnode+0x98>                    
        the_jnode->info.device.major, the_jnode->info.device.minor ); 
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      fprintf(stdout, " (file %" PRId32 " %p)",                       
    3d48:	e5952000 	ldr	r2, [r5]                                      <== NOT EXECUTED
    3d4c:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
    3d50:	e5920008 	ldr	r0, [r2, #8]                                  <== NOT EXECUTED
    3d54:	e59f10b8 	ldr	r1, [pc, #184]	; 3e14 <IMFS_print_jnode+0x154><== NOT EXECUTED
    3d58:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          
    3d5c:	eb0036c8 	bl	11884 <fprintf>                                
        (uint32_t)the_jnode->info.linearfile.size,                    
        the_jnode->info.linearfile.direct                             
      );                                                              
      break;                                                          
    3d60:	ea000023 	b	3df4 <IMFS_print_jnode+0x134>                   
        the_jnode->info.file.indirect,                                
        the_jnode->info.file.doubly_indirect,                         
        the_jnode->info.file.triply_indirect                          
      );                                                              
#else                                                                 
      fprintf(stdout, " (file %" PRId32 ")",                          
    3d64:	e5953000 	ldr	r3, [r5]                                      
    3d68:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          
    3d6c:	e5930008 	ldr	r0, [r3, #8]                                  
    3d70:	e59f10a0 	ldr	r1, [pc, #160]	; 3e18 <IMFS_print_jnode+0x158>
    3d74:	eb0036c2 	bl	11884 <fprintf>                                
        (uint32_t)the_jnode->info.file.size );                        
#endif                                                                
      break;                                                          
    3d78:	ea00001d 	b	3df4 <IMFS_print_jnode+0x134>                   
                                                                      
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
    3d7c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
    3d80:	e59f0094 	ldr	r0, [pc, #148]	; 3e1c <IMFS_print_jnode+0x15c><== NOT EXECUTED
    3d84:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
    3d88:	eb00371e 	bl	11a08 <fputs>                                  <== NOT EXECUTED
      assert(0);                                                      
    3d8c:	e59f006c 	ldr	r0, [pc, #108]	; 3e00 <IMFS_print_jnode+0x140><== NOT EXECUTED
    3d90:	e3a0105d 	mov	r1, #93	; 0x5d                                <== NOT EXECUTED
    3d94:	e59f2068 	ldr	r2, [pc, #104]	; 3e04 <IMFS_print_jnode+0x144><== NOT EXECUTED
    3d98:	e59f3080 	ldr	r3, [pc, #128]	; 3e20 <IMFS_print_jnode+0x160><== NOT EXECUTED
    3d9c:	eb000249 	bl	46c8 <__assert_func>                           <== NOT EXECUTED
      break;                                                          
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
    3da0:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
    3da4:	e59f0070 	ldr	r0, [pc, #112]	; 3e1c <IMFS_print_jnode+0x15c><== NOT EXECUTED
    3da8:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
    3dac:	eb003715 	bl	11a08 <fputs>                                  <== NOT EXECUTED
      assert(0);                                                      
    3db0:	e59f0048 	ldr	r0, [pc, #72]	; 3e00 <IMFS_print_jnode+0x140> <== NOT EXECUTED
    3db4:	e3a01062 	mov	r1, #98	; 0x62                                <== NOT EXECUTED
    3db8:	eafffff5 	b	3d94 <IMFS_print_jnode+0xd4>                    <== NOT EXECUTED
      break;                                                          
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
    3dbc:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
    3dc0:	e59f005c 	ldr	r0, [pc, #92]	; 3e24 <IMFS_print_jnode+0x164> <== NOT EXECUTED
    3dc4:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
    3dc8:	eb00370e 	bl	11a08 <fputs>                                  <== NOT EXECUTED
      assert(0);                                                      
    3dcc:	e59f002c 	ldr	r0, [pc, #44]	; 3e00 <IMFS_print_jnode+0x140> <== NOT EXECUTED
    3dd0:	e3a01067 	mov	r1, #103	; 0x67                               <== NOT EXECUTED
    3dd4:	eaffffee 	b	3d94 <IMFS_print_jnode+0xd4>                    <== NOT EXECUTED
      break;                                                          
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
    3dd8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
    3ddc:	e59f1044 	ldr	r1, [pc, #68]	; 3e28 <IMFS_print_jnode+0x168> <== NOT EXECUTED
    3de0:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
    3de4:	eb0036a6 	bl	11884 <fprintf>                                <== NOT EXECUTED
      assert(0);                                                      
    3de8:	e59f0010 	ldr	r0, [pc, #16]	; 3e00 <IMFS_print_jnode+0x140> <== NOT EXECUTED
    3dec:	e3a0106c 	mov	r1, #108	; 0x6c                               <== NOT EXECUTED
    3df0:	eaffffe7 	b	3d94 <IMFS_print_jnode+0xd4>                    <== NOT EXECUTED
      break;                                                          
  }                                                                   
  puts("");                                                           
    3df4:	e59f0030 	ldr	r0, [pc, #48]	; 3e2c <IMFS_print_jnode+0x16c> 
}                                                                     
    3df8:	e8bd4030 	pop	{r4, r5, lr}                                  
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      assert(0);                                                      
      break;                                                          
  }                                                                   
  puts("");                                                           
    3dfc:	ea003dcf 	b	13540 <puts>                                    
                                                                      

000017e8 <IMFS_readlink>: ) { IMFS_jnode_t *node; int i; node = loc->node_access;
    17e8:	e5903000 	ldr	r3, [r0]                                      
                                                                      
  if ( node->type != IMFS_SYM_LINK )                                  
    17ec:	e593004c 	ldr	r0, [r3, #76]	; 0x4c                          
    17f0:	e3500004 	cmp	r0, #4                                        
int IMFS_readlink(                                                    
  rtems_filesystem_location_info_t  *loc,                             
 char                               *buf,         /* OUT */           
 size_t                             bufsize                           
)                                                                     
{                                                                     
    17f4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  IMFS_jnode_t      *node;                                            
  int                i;                                               
                                                                      
  node = loc->node_access;                                            
                                                                      
  if ( node->type != IMFS_SYM_LINK )                                  
    17f8:	03a00000 	moveq	r0, #0                                      
    17fc:	0a000006 	beq	181c <IMFS_readlink+0x34>                     
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    1800:	eb002eef 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1804:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    1808:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    180c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    1810:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
    buf[i] = node->info.sym_link.name[i];                             
    1814:	e7c1c000 	strb	ip, [r1, r0]                                 
  node = loc->node_access;                                            
                                                                      
  if ( node->type != IMFS_SYM_LINK )                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
    1818:	e2800001 	add	r0, r0, #1                                    
    181c:	e1500002 	cmp	r0, r2                                        
    1820:	249df004 	popcs	{pc}		; (ldrcs pc, [sp], #4)                
    1824:	e593c050 	ldr	ip, [r3, #80]	; 0x50                          
    1828:	e7dcc000 	ldrb	ip, [ip, r0]                                 
    182c:	e35c0000 	cmp	ip, #0                                        
    1830:	1afffff7 	bne	1814 <IMFS_readlink+0x2c>                     
    buf[i] = node->info.sym_link.name[i];                             
                                                                      
  return i;                                                           
}                                                                     
    1834:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

00009f1c <IMFS_stat>: { IMFS_fs_info_t *fs_info; IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access;
    9f1c:	e5903000 	ldr	r3, [r0]                                      
                                                                      
                                                                      
  switch ( the_jnode->type ) {                                        
    9f20:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          
    9f24:	e2422002 	sub	r2, r2, #2                                    
                                                                      
int IMFS_stat(                                                        
  rtems_filesystem_location_info_t *loc,                              
  struct stat                      *buf                               
)                                                                     
{                                                                     
    9f28:	e92d4810 	push	{r4, fp, lr}                                 
  IMFS_device_t  *io;                                                 
                                                                      
  the_jnode = loc->node_access;                                       
                                                                      
                                                                      
  switch ( the_jnode->type ) {                                        
    9f2c:	e3520005 	cmp	r2, #5                                        
    9f30:	979ff102 	ldrls	pc, [pc, r2, lsl #2]                        
    9f34:	ea000012 	b	9f84 <IMFS_stat+0x68>                           <== NOT EXECUTED
    9f38:	00009f50 	.word	0x00009f50                                  <== NOT EXECUTED
    9f3c:	00009f84 	.word	0x00009f84                                  <== NOT EXECUTED
    9f40:	00009f70 	.word	0x00009f70                                  <== NOT EXECUTED
    9f44:	00009f64 	.word	0x00009f64                                  <== NOT EXECUTED
    9f48:	00009f64 	.word	0x00009f64                                  <== NOT EXECUTED
    9f4c:	00009f70 	.word	0x00009f70                                  <== NOT EXECUTED
                                                                      
    case IMFS_DEVICE:                                                 
      io           = &the_jnode->info.device;                         
      buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
    9f50:	e2832050 	add	r2, r3, #80	; 0x50                            
    9f54:	e8921004 	ldm	r2, {r2, ip}                                  
    9f58:	e581c01c 	str	ip, [r1, #28]                                 
    9f5c:	e5812018 	str	r2, [r1, #24]                                 
      break;                                                          
    9f60:	ea00000c 	b	9f98 <IMFS_stat+0x7c>                           
                                                                      
    case IMFS_LINEAR_FILE:                                            
    case IMFS_MEMORY_FILE:                                            
      buf->st_size = the_jnode->info.file.size;                       
    9f64:	e283c050 	add	ip, r3, #80	; 0x50                            
    9f68:	e89c1800 	ldm	ip, {fp, ip}                                  
    9f6c:	ea000001 	b	9f78 <IMFS_stat+0x5c>                           
    case IMFS_SYM_LINK:                                               
      buf->st_size = 0;                                               
      break;                                                          
                                                                      
    case IMFS_FIFO:                                                   
      buf->st_size = 0;                                               
    9f70:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
    9f74:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
    9f78:	e581b020 	str	fp, [r1, #32]                                 
    9f7c:	e581c024 	str	ip, [r1, #36]	; 0x24                          
      break;                                                          
    9f80:	ea000004 	b	9f98 <IMFS_stat+0x7c>                           
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( ENOTSUP );                
    9f84:	eb000d0e 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    9f88:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    9f8c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    9f90:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    9f94:	e8bd8810 	pop	{r4, fp, pc}                                  <== 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;                                 
    9f98:	e5932030 	ldr	r2, [r3, #48]	; 0x30                          
    9f9c:	e581200c 	str	r2, [r1, #12]                                 
  buf->st_nlink = the_jnode->st_nlink;                                
  buf->st_ino   = the_jnode->st_ino;                                  
    9fa0:	e5932038 	ldr	r2, [r3, #56]	; 0x38                          
    9fa4:	e5812008 	str	r2, [r1, #8]                                  
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
    9fa8:	e5932040 	ldr	r2, [r3, #64]	; 0x40                          
    9fac:	e5812028 	str	r2, [r1, #40]	; 0x28                          
   * 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 );
    9fb0:	e5902010 	ldr	r2, [r0, #16]                                 
  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;                              
    9fb4:	e5930044 	ldr	r0, [r3, #68]	; 0x44                          
  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;                                
    9fb8:	e1d343b4 	ldrh	r4, [r3, #52]	; 0x34                         
  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;                              
    9fbc:	e5810030 	str	r0, [r1, #48]	; 0x30                          
  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;                                
    9fc0:	e1c141b0 	strh	r4, [r1, #16]                                
   * 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 );
    9fc4:	e5920034 	ldr	r0, [r2, #52]	; 0x34                          
  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;                              
    9fc8:	e5932048 	ldr	r2, [r3, #72]	; 0x48                          
                                                                      
  buf->st_blksize = imfs_rq_memfile_bytes_per_block;                  
    9fcc:	e59fc030 	ldr	ip, [pc, #48]	; a004 <IMFS_stat+0xe8>         
  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;                              
    9fd0:	e5812038 	str	r2, [r1, #56]	; 0x38                          
    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;                                  
    9fd4:	e1d323bc 	ldrh	r2, [r3, #60]	; 0x3c                         
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  buf->st_mtime = the_jnode->stat_mtime;                              
  buf->st_ctime = the_jnode->stat_ctime;                              
                                                                      
  buf->st_blksize = imfs_rq_memfile_bytes_per_block;                  
    9fd8:	e59cc000 	ldr	ip, [ip]                                      
    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;                                  
    9fdc:	e1c121b2 	strh	r2, [r1, #18]                                
   * 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 );
    9fe0:	e5900000 	ldr	r0, [r0]                                      
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  buf->st_mtime = the_jnode->stat_mtime;                              
  buf->st_ctime = the_jnode->stat_ctime;                              
                                                                      
  buf->st_blksize = imfs_rq_memfile_bytes_per_block;                  
    9fe4:	e581c040 	str	ip, [r1, #64]	; 0x40                          
                                                                      
  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;                                  
    9fe8:	e1d333be 	ldrh	r3, [r3, #62]	; 0x3e                         
  /*                                                                  
   * 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 =                                                       
    9fec:	e59fc014 	ldr	ip, [pc, #20]	; a008 <IMFS_stat+0xec>         
    9ff0:	e5810004 	str	r0, [r1, #4]                                  
    9ff4:	e581c000 	str	ip, [r1]                                      
                                                                      
  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;                                  
    9ff8:	e1c131b4 	strh	r3, [r1, #20]                                
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  buf->st_mtime = the_jnode->stat_mtime;                              
  buf->st_ctime = the_jnode->stat_ctime;                              
                                                                      
  buf->st_blksize = imfs_rq_memfile_bytes_per_block;                  
    9ffc:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
    a000:	e8bd8810 	pop	{r4, fp, pc}                                  
                                                                      

00001894 <IMFS_symlink>: int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) {
    1894:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
    1898:	e1a05000 	mov	r5, r0                                        
    189c:	e24dd040 	sub	sp, sp, #64	; 0x40                            
  int                i;                                               
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
  IMFS_get_token( node_name, strlen( node_name ), new_name, &i );     
    18a0:	e1a00002 	mov	r0, r2                                        
int IMFS_symlink(                                                     
  rtems_filesystem_location_info_t  *parent_loc,                      
  const char                        *link_name,                       
  const char                        *node_name                        
)                                                                     
{                                                                     
    18a4:	e1a07002 	mov	r7, r2                                        
    18a8:	e1a06001 	mov	r6, r1                                        
  int                i;                                               
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
  IMFS_get_token( node_name, strlen( node_name ), new_name, &i );     
    18ac:	eb0032c9 	bl	e3d8 <strlen>                                  
    18b0:	e28d4004 	add	r4, sp, #4                                    
    18b4:	e1a01000 	mov	r1, r0                                        
    18b8:	e1a02004 	mov	r2, r4                                        
    18bc:	e28d303c 	add	r3, sp, #60	; 0x3c                            
    18c0:	e1a00007 	mov	r0, r7                                        
    18c4:	eb002135 	bl	9da0 <IMFS_get_token>                          
                                                                      
  /*                                                                  
   * Duplicate link name                                              
   */                                                                 
  info.sym_link.name = strdup(link_name);                             
    18c8:	e1a00006 	mov	r0, r6                                        
    18cc:	eb0032ad 	bl	e388 <strdup>                                  
  if (info.sym_link.name == NULL) {                                   
    18d0:	e3500000 	cmp	r0, #0                                        
  IMFS_get_token( node_name, strlen( node_name ), new_name, &i );     
                                                                      
  /*                                                                  
   * Duplicate link name                                              
   */                                                                 
  info.sym_link.name = strdup(link_name);                             
    18d4:	e58d0028 	str	r0, [sp, #40]	; 0x28                          
  if (info.sym_link.name == NULL) {                                   
    18d8:	0a00000b 	beq	190c <IMFS_symlink+0x78>                      
   *        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(                                        
    18dc:	e28dc028 	add	ip, sp, #40	; 0x28                            
    18e0:	e1a00005 	mov	r0, r5                                        
    18e4:	e1a02004 	mov	r2, r4                                        
    18e8:	e3a01004 	mov	r1, #4                                        
    18ec:	e59f3030 	ldr	r3, [pc, #48]	; 1924 <IMFS_symlink+0x90>      
    18f0:	e58dc000 	str	ip, [sp]                                      
    18f4:	eb001df4 	bl	90cc <IMFS_create_node>                        
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if (new_node == NULL) {                                             
    18f8:	e3500000 	cmp	r0, #0                                        
    18fc:	13a00000 	movne	r0, #0                                      
    1900:	1a000005 	bne	191c <IMFS_symlink+0x88>                      
    free(info.sym_link.name);                                         
    1904:	e59d0028 	ldr	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
    1908:	eb000170 	bl	1ed0 <free>                                    <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
    190c:	eb002eac 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1910:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    1914:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1918:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
    191c:	e28dd040 	add	sp, sp, #64	; 0x40                            
    1920:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

00001928 <IMFS_unlink>: int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) {
    1928:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  IMFS_jnode_t                      *node;                            
  rtems_filesystem_location_info_t   the_link;                        
  int                                result = 0;                      
                                                                      
  node = loc->node_access;                                            
    192c:	e5915000 	ldr	r5, [r1]                                      
  /*                                                                  
   * If this is the last last pointer to the node                     
   * free the node.                                                   
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
    1930:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
    1934:	e3530003 	cmp	r3, #3                                        
                                                                      
int IMFS_unlink(                                                      
  rtems_filesystem_location_info_t  *parentloc, /* IN */              
  rtems_filesystem_location_info_t  *loc        /* IN */              
)                                                                     
{                                                                     
    1938:	e24dd01c 	sub	sp, sp, #28                                   
    193c:	e1a04001 	mov	r4, r1                                        
    1940:	e1a06000 	mov	r6, r0                                        
  /*                                                                  
   * If this is the last last pointer to the node                     
   * free the node.                                                   
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
    1944:	1a000025 	bne	19e0 <IMFS_unlink+0xb8>                       
                                                                      
    if ( !node->info.hard_link.link_node )                            
    1948:	e595e050 	ldr	lr, [r5, #80]	; 0x50                          
    194c:	e35e0000 	cmp	lr, #0                                        
    1950:	1a000003 	bne	1964 <IMFS_unlink+0x3c>                       
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    1954:	eb002e9a 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1958:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    195c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1960:	ea000014 	b	19b8 <IMFS_unlink+0x90>                         <== NOT EXECUTED
                                                                      
    the_link = *loc;                                                  
    1964:	e1a07001 	mov	r7, r1                                        
    1968:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         
    196c:	e1a0c00d 	mov	ip, sp                                        
    1970:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    the_link.node_access = node->info.hard_link.link_node;            
    1974:	e28d801c 	add	r8, sp, #28                                   
    1978:	e528e01c 	str	lr, [r8, #-28]!                               
  if ( node->type == IMFS_HARD_LINK ) {                               
                                                                      
    if ( !node->info.hard_link.link_node )                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    the_link = *loc;                                                  
    197c:	e5973000 	ldr	r3, [r7]                                      
    the_link.node_access = node->info.hard_link.link_node;            
    IMFS_Set_handlers( &the_link );                                   
    1980:	e1a0000d 	mov	r0, sp                                        
  if ( node->type == IMFS_HARD_LINK ) {                               
                                                                      
    if ( !node->info.hard_link.link_node )                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    the_link = *loc;                                                  
    1984:	e58c3000 	str	r3, [ip]                                      
    the_link.node_access = node->info.hard_link.link_node;            
    IMFS_Set_handlers( &the_link );                                   
    1988:	eb001e1e 	bl	9208 <IMFS_Set_handlers>                       
    /*                                                                
     *  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)               
    198c:	e5953050 	ldr	r3, [r5, #80]	; 0x50                          
    1990:	e1d323b4 	ldrh	r2, [r3, #52]	; 0x34                         
    1994:	e3520001 	cmp	r2, #1                                        
    1998:	1a000008 	bne	19c0 <IMFS_unlink+0x98>                       
    {                                                                 
        result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
    199c:	e1a0100d 	mov	r1, sp                                        
    19a0:	e1a00006 	mov	r0, r6                                        
    19a4:	e59d3008 	ldr	r3, [sp, #8]                                  
    19a8:	e1a0e00f 	mov	lr, pc                                        
    19ac:	e593f034 	ldr	pc, [r3, #52]	; 0x34                          
        if ( result != 0 )                                            
    19b0:	e3500000 	cmp	r0, #0                                        
    19b4:	0a000009 	beq	19e0 <IMFS_unlink+0xb8>                       
    19b8:	e3e00000 	mvn	r0, #0                                        
    19bc:	ea00000c 	b	19f4 <IMFS_unlink+0xcc>                         
            return -1;                                                
    }                                                                 
    else                                                              
    {                                                                 
        node->info.hard_link.link_node->st_nlink --;                  
    19c0:	e2422001 	sub	r2, r2, #1                                    
    19c4:	e1c323b4 	strh	r2, [r3, #52]	; 0x34                         
        IMFS_update_ctime( node->info.hard_link.link_node );          
    19c8:	e28d0014 	add	r0, sp, #20                                   
    19cc:	e3a01000 	mov	r1, #0                                        
    19d0:	eb000167 	bl	1f74 <gettimeofday>                            
    19d4:	e5953050 	ldr	r3, [r5, #80]	; 0x50                          
    19d8:	e59d2014 	ldr	r2, [sp, #20]                                 
    19dc:	e5832048 	str	r2, [r3, #72]	; 0x48                          
                                                                      
  /*                                                                  
   *  Now actually free the node we were asked to free.               
   */                                                                 
                                                                      
  result = (*loc->handlers->rmnod_h)( parentloc, loc );               
    19e0:	e1a00006 	mov	r0, r6                                        
    19e4:	e1a01004 	mov	r1, r4                                        
    19e8:	e5943008 	ldr	r3, [r4, #8]                                  
    19ec:	e1a0e00f 	mov	lr, pc                                        
    19f0:	e593f034 	ldr	pc, [r3, #52]	; 0x34                          
                                                                      
  return result;                                                      
}                                                                     
    19f4:	e28dd01c 	add	sp, sp, #28                                   
    19f8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

000019fc <IMFS_unmount>: rtems_filesystem_mount_table_entry_t *mt_entry ) { IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access;
    19fc:	e5903008 	ldr	r3, [r0, #8]                                  
                                                                      
  /*                                                                  
   * Is the node that we are mounting onto a directory node ?         
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
    1a00:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          
    1a04:	e3520001 	cmp	r2, #1                                        
#include <rtems/seterr.h>                                             
                                                                      
int IMFS_unmount(                                                     
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
    1a08:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
                                                                      
  /*                                                                  
   * Is the node that we are mounting onto a directory node ?         
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
    1a0c:	0a000002 	beq	1a1c <IMFS_unmount+0x20>                      
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
    1a10:	eb002e6b 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1a14:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
    1a18:	ea000004 	b	1a30 <IMFS_unmount+0x34>                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Did the node indicate that there was a directory mounted here?   
   */                                                                 
                                                                      
  if ( node->info.directory.mt_fs == NULL )                           
    1a1c:	e593205c 	ldr	r2, [r3, #92]	; 0x5c                          
    1a20:	e3520000 	cmp	r2, #0                                        
    1a24:	1a000004 	bne	1a3c <IMFS_unmount+0x40>                      
    rtems_set_errno_and_return_minus_one( EINVAL );  /* XXX */        
    1a28:	eb002e65 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1a2c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    1a30:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1a34:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    1a38:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== 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;                                  
    1a3c:	e3a00000 	mov	r0, #0                                        
    1a40:	e583005c 	str	r0, [r3, #92]	; 0x5c                          
                                                                      
  return 0;                                                           
}                                                                     
    1a44:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

00002118 <RTEMS_Malloc_Initialize>: #endif /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers != NULL ) {
    2118:	e59f30c8 	ldr	r3, [pc, #200]	; 21e8 <RTEMS_Malloc_Initialize+0xd0>
    211c:	e5933000 	ldr	r3, [r3]                                      
    2120:	e3530000 	cmp	r3, #0                                        
void RTEMS_Malloc_Initialize(                                         
  void *heap_begin,                                                   
  uintptr_t heap_size,                                                
  size_t sbrk_amount                                                  
)                                                                     
{                                                                     
    2124:	e92d4070 	push	{r4, r5, r6, lr}                             
    2128:	e1a04000 	mov	r4, r0                                        
    212c:	e1a05001 	mov	r5, r1                                        
    2130:	e1a06002 	mov	r6, r2                                        
                                                                      
  /*                                                                  
   *  If configured, initialize the statistics support                
   */                                                                 
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
    (*rtems_malloc_statistics_helpers->initialize)();                 
    2134:	11a0e00f 	movne	lr, pc                                      
    2138:	1593f000 	ldrne	pc, [r3]                                    
  }                                                                   
                                                                      
  /*                                                                  
   *  Initialize the garbage collection list to start with nothing on it.
   */                                                                 
  malloc_deferred_frees_initialize();                                 
    213c:	ebffffe1 	bl	20c8 <malloc_deferred_frees_initialize>        
                                                                      
  /*                                                                  
   *  Initialize the optional sbrk support for extending the heap     
   */                                                                 
  if ( rtems_malloc_sbrk_helpers != NULL ) {                          
    2140:	e59f30a4 	ldr	r3, [pc, #164]	; 21ec <RTEMS_Malloc_Initialize+0xd4>
    2144:	e5933000 	ldr	r3, [r3]                                      
    2148:	e3530000 	cmp	r3, #0                                        
    214c:	0a000006 	beq	216c <RTEMS_Malloc_Initialize+0x54>           
    void *new_heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(  
    2150:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    2154:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    2158:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    215c:	e593f000 	ldr	pc, [r3]                                      <== NOT EXECUTED
      heap_begin,                                                     
      sbrk_amount                                                     
    );                                                                
                                                                      
    heap_size -= (uintptr_t) new_heap_begin - (uintptr_t) heap_begin; 
    2160:	e0845005 	add	r5, r4, r5                                    <== NOT EXECUTED
    2164:	e0605005 	rsb	r5, r0, r5                                    <== NOT EXECUTED
    2168:	e1a04000 	mov	r4, 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 (                                                                
    216c:	e59f307c 	ldr	r3, [pc, #124]	; 21f0 <RTEMS_Malloc_Initialize+0xd8>
    2170:	e5d31000 	ldrb	r1, [r3]                                     
    2174:	e3510000 	cmp	r1, #0                                        
    2178:	1a000005 	bne	2194 <RTEMS_Malloc_Initialize+0x7c>           
    !rtems_unified_work_area                                          
      && rtems_configuration_get_do_zero_of_workspace()               
    217c:	e59f3070 	ldr	r3, [pc, #112]	; 21f4 <RTEMS_Malloc_Initialize+0xdc>
    2180:	e5d33028 	ldrb	r3, [r3, #40]	; 0x28                         
    2184:	e3530000 	cmp	r3, #0                                        
  ) {                                                                 
     memset( heap_begin, 0, heap_size );                              
    2188:	11a00004 	movne	r0, r4                                      
    218c:	11a02005 	movne	r2, r5                                      
    2190:	1b002ed5 	blne	dcec <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 ) {                                   
    2194:	e59f3054 	ldr	r3, [pc, #84]	; 21f0 <RTEMS_Malloc_Initialize+0xd8>
    2198:	e5d33000 	ldrb	r3, [r3]                                     
    219c:	e3530000 	cmp	r3, #0                                        
    21a0:	1a000008 	bne	21c8 <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 );  
    21a4:	e59f304c 	ldr	r3, [pc, #76]	; 21f8 <RTEMS_Malloc_Initialize+0xe0>
    21a8:	e1a01004 	mov	r1, r4                                        
    21ac:	e5930000 	ldr	r0, [r3]                                      
    21b0:	e1a02005 	mov	r2, r5                                        
    21b4:	e3a03004 	mov	r3, #4                                        
    21b8:	eb000f71 	bl	5f84 <_Heap_Initialize>                        
      RTEMS_Malloc_Heap,                                              
      heap_begin,                                                     
      heap_size,                                                      
      CPU_HEAP_ALIGNMENT                                              
    );                                                                
    if ( status == 0 ) {                                              
    21bc:	e3500000 	cmp	r0, #0                                        
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
    21c0:	0280001a 	addeq	r0, r0, #26                                 
    21c4:	0b000d77 	bleq	57a8 <rtems_fatal_error_occurred>            
    }                                                                 
  }                                                                   
                                                                      
  MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
    21c8:	e59f3028 	ldr	r3, [pc, #40]	; 21f8 <RTEMS_Malloc_Initialize+0xe0>
    21cc:	e59f4028 	ldr	r4, [pc, #40]	; 21fc <RTEMS_Malloc_Initialize+0xe4>
    21d0:	e5930000 	ldr	r0, [r3]                                      
    21d4:	e5945000 	ldr	r5, [r4]                                      
    21d8:	eb001240 	bl	6ae0 <_Protected_heap_Get_size>                
    21dc:	e0800005 	add	r0, r0, r5                                    
    21e0:	e5840000 	str	r0, [r4]                                      
      printk( "\n" );                                                 
      rtems_print_buffer( (heap_begin + heap_size) - 48, 48 );        
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
    }                                                                 
  #endif                                                              
}                                                                     
    21e4:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00005bfc <Stack_check_Dump_threads_usage>: static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) {
    5bfc:	e92d47ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}<== NOT EXECUTED
  void           *high_water_mark;                                    
  void           *current;                                            
  Stack_Control  *stack;                                              
  char            name[5];                                            
                                                                      
  if ( !the_thread )                                                  
    5c00:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
    5c04:	0a000043 	beq	5d18 <Stack_check_Dump_threads_usage+0x11c>   <== NOT EXECUTED
    return;                                                           
                                                                      
  if ( !print_handler )                                               
    5c08:	e59f310c 	ldr	r3, [pc, #268]	; 5d1c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
    5c0c:	e5937004 	ldr	r7, [r3, #4]                                  <== NOT EXECUTED
    5c10:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    5c14:	0a00003f 	beq	5d18 <Stack_check_Dump_threads_usage+0x11c>   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Obtain interrupt stack information                              
   */                                                                 
                                                                      
  if (the_thread == (Thread_Control *) -1) {                          
    5c18:	e37a0001 	cmn	sl, #1                                        <== NOT EXECUTED
    }                                                                 
    else                                                              
      return;                                                         
  } else {                                                            
    stack  = &the_thread->Start.Initial_stack;                        
    current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );  
    5c1c:	159a60f0 	ldrne	r6, [sl, #240]	; 0xf0                       <== NOT EXECUTED
      current = 0;                                                    
    }                                                                 
    else                                                              
      return;                                                         
  } else {                                                            
    stack  = &the_thread->Start.Initial_stack;                        
    5c20:	128a40c0 	addne	r4, sl, #192	; 0xc0                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Obtain interrupt stack information                              
   */                                                                 
                                                                      
  if (the_thread == (Thread_Control *) -1) {                          
    5c24:	1a000005 	bne	5c40 <Stack_check_Dump_threads_usage+0x44>    <== NOT EXECUTED
    if (Stack_check_Interrupt_stack.area) {                           
    5c28:	e59f40f0 	ldr	r4, [pc, #240]	; 5d20 <Stack_check_Dump_threads_usage+0x124><== NOT EXECUTED
    5c2c:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
    5c30:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    5c34:	13a06000 	movne	r6, #0                                      <== NOT EXECUTED
    5c38:	11a0a006 	movne	sl, r6                                      <== NOT EXECUTED
    5c3c:	0a000035 	beq	5d18 <Stack_check_Dump_threads_usage+0x11c>   <== NOT EXECUTED
  } else {                                                            
    stack  = &the_thread->Start.Initial_stack;                        
    current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );  
  }                                                                   
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
    5c40:	e8940220 	ldm	r4, {r5, r9}                                  <== NOT EXECUTED
    5c44:	e2899010 	add	r9, r9, #16                                   <== NOT EXECUTED
  size = Stack_check_usable_stack_size(stack);                        
    5c48:	e2455010 	sub	r5, r5, #16                                   <== NOT EXECUTED
                                                                      
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
    5c4c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
    5c50:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    5c54:	ebffffda 	bl	5bc4 <Stack_check_find_high_water_mark>        <== NOT EXECUTED
                                                                      
  if ( high_water_mark )                                              
    5c58:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
    5c5c:	10899005 	addne	r9, r9, r5                                  <== NOT EXECUTED
    5c60:	10688009 	rsbne	r8, r8, r9                                  <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
  if ( the_thread ) {                                                 
    5c64:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
    5c68:	e59f30ac 	ldr	r3, [pc, #172]	; 5d1c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
    5c6c:	0a00000c 	beq	5ca4 <Stack_check_Dump_threads_usage+0xa8>    <== NOT EXECUTED
    (*print_handler)(                                                 
    5c70:	e59aa008 	ldr	sl, [sl, #8]                                  <== NOT EXECUTED
    5c74:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
    5c78:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
    5c7c:	e3a01005 	mov	r1, #5                                        <== NOT EXECUTED
    5c80:	e5939008 	ldr	r9, [r3, #8]                                  <== NOT EXECUTED
    5c84:	eb001663 	bl	b618 <rtems_object_get_name>                   <== NOT EXECUTED
    5c88:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
    5c8c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    5c90:	e59f108c 	ldr	r1, [pc, #140]	; 5d24 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
    5c94:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
    5c98:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5c9c:	e12fff17 	bx	r7                                             <== NOT EXECUTED
    5ca0:	ea000004 	b	5cb8 <Stack_check_Dump_threads_usage+0xbc>      <== NOT EXECUTED
      "0x%08" PRIx32 "  %4s",                                         
      the_thread->Object.id,                                          
      rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
    );                                                                
  } else {                                                            
    (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );   
    5ca4:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
    5ca8:	e59f1078 	ldr	r1, [pc, #120]	; 5d28 <Stack_check_Dump_threads_usage+0x12c><== NOT EXECUTED
    5cac:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
    5cb0:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5cb4:	e12fff17 	bx	r7                                             <== NOT EXECUTED
  }                                                                   
                                                                      
  (*print_handler)(                                                   
    5cb8:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
    5cbc:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
    5cc0:	e59f4054 	ldr	r4, [pc, #84]	; 5d1c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
    5cc4:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
    5cc8:	e58d5004 	str	r5, [sp, #4]                                  <== NOT EXECUTED
    5ccc:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    5cd0:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
    5cd4:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    5cd8:	e59f104c 	ldr	r1, [pc, #76]	; 5d2c <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
    5cdc:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5ce0:	e594f004 	ldr	pc, [r4, #4]                                  <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
    5ce4:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
    5ce8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    5cec:	1a000004 	bne	5d04 <Stack_check_Dump_threads_usage+0x108>   <== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
    5cf0:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    5cf4:	e59f1034 	ldr	r1, [pc, #52]	; 5d30 <Stack_check_Dump_threads_usage+0x134><== NOT EXECUTED
    5cf8:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5cfc:	e594f004 	ldr	pc, [r4, #4]                                  <== NOT EXECUTED
    5d00:	ea000004 	b	5d18 <Stack_check_Dump_threads_usage+0x11c>     <== NOT EXECUTED
  } else {                                                            
    (*print_handler)( print_context, "%8" PRId32 "\n", used );        
    5d04:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
    5d08:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    5d0c:	e59f1020 	ldr	r1, [pc, #32]	; 5d34 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
    5d10:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5d14:	e594f004 	ldr	pc, [r4, #4]                                  <== NOT EXECUTED
  }                                                                   
                                                                      
                                                                      
}                                                                     
    5d18:	e8bd87ff 	pop	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}<== NOT EXECUTED
                                                                      

00005bc4 <Stack_check_find_high_water_mark>: /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS;
    5bc4:	e2800010 	add	r0, r0, #16                                   <== NOT EXECUTED
    for (ebase = base + length; base < ebase; base++)                 
    5bc8:	e3c11003 	bic	r1, r1, #3                                    <== NOT EXECUTED
    5bcc:	e0801001 	add	r1, r0, r1                                    <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
    5bd0:	e59f3020 	ldr	r3, [pc, #32]	; 5bf8 <Stack_check_find_high_water_mark+0x34><== 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++)                 
    5bd4:	ea000003 	b	5be8 <Stack_check_find_high_water_mark+0x24>    <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
    5bd8:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
    5bdc:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    5be0:	112fff1e 	bxne	lr                                           <== 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++)                 
    5be4:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
    5be8:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
    5bec:	3afffff9 	bcc	5bd8 <Stack_check_find_high_water_mark+0x14>  <== NOT EXECUTED
    5bf0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
        return (void *) base;                                         
  #endif                                                              
                                                                      
  return (void *)0;                                                   
}                                                                     
    5bf4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0003c678 <T.57>: return 0; } static int rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c678:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_rfs_bitmap_element* map_bits;                                 
  int                       map_index;                                
  int                       map_offset;                               
  int                       rc;                                       
                                                                      
  *found = false;                                                     
   3c67c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c680:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
   3c684:	e58d1008 	str	r1, [sp, #8]                                  <== NOT EXECUTED
  rtems_rfs_bitmap_element* map_bits;                                 
  int                       map_index;                                
  int                       map_offset;                               
  int                       rc;                                       
                                                                      
  *found = false;                                                     
   3c688:	e5c26000 	strb	r6, [r2]                                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c68c:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c690:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
   3c694:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
   3c698:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  *found = false;                                                     
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c69c:	ebffff07 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c6a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c6a4:	ca000075 	bgt	3c880 <T.57+0x208>                            <== NOT EXECUTED
    return rc;                                                        
                                                                      
  /*                                                                  
   * Calculate the bit we are testing plus the end point we search over.
   */                                                                 
  test_bit = *bit;                                                    
   3c6a8:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
   3c6ac:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  end_bit  = test_bit + (window * direction);                         
                                                                      
  if (end_bit < 0)                                                    
   3c6b0:	e093c584 	adds	ip, r3, r4, lsl #11                          <== NOT EXECUTED
   3c6b4:	41a0c006 	movmi	ip, r6                                      <== NOT EXECUTED
   3c6b8:	4a000002 	bmi	3c6c8 <T.57+0x50>                             <== NOT EXECUTED
    end_bit = 0;                                                      
  else if (end_bit >= control->size)                                  
   3c6bc:	e595200c 	ldr	r2, [r5, #12]                                 <== NOT EXECUTED
   3c6c0:	e15c0002 	cmp	ip, r2                                        <== NOT EXECUTED
    end_bit = control->size - 1;                                      
   3c6c4:	2242c001 	subcs	ip, r2, #1                                  <== NOT EXECUTED
  map_index     = rtems_rfs_bitmap_map_index (test_bit);              
  map_offset    = rtems_rfs_bitmap_map_offset (test_bit);             
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
  search_offset = rtems_rfs_bitmap_map_offset (map_index);            
                                                                      
  search_bits = &control->search_bits[search_index];                  
   3c6c8:	e5952014 	ldr	r2, [r5, #20]                                 <== NOT EXECUTED
  map_bits    = &map[map_index];                                      
   3c6cc:	e59d7018 	ldr	r7, [sp, #24]                                 <== NOT EXECUTED
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
   3c6d0:	e1a09104 	lsl	r9, r4, #2                                    <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c6d4:	e1a0b284 	lsl	fp, r4, #5                                    <== NOT EXECUTED
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
   3c6d8:	e1a00fa4 	lsr	r0, r4, #31                                   <== NOT EXECUTED
  if (end_bit < 0)                                                    
    end_bit = 0;                                                      
  else if (end_bit >= control->size)                                  
    end_bit = control->size - 1;                                      
                                                                      
  map_index     = rtems_rfs_bitmap_map_index (test_bit);              
   3c6dc:	e1a062c3 	asr	r6, r3, #5                                    <== NOT EXECUTED
  map_offset    = rtems_rfs_bitmap_map_offset (test_bit);             
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
  search_offset = rtems_rfs_bitmap_map_offset (map_index);            
                                                                      
  search_bits = &control->search_bits[search_index];                  
   3c6e0:	e1a08543 	asr	r8, r3, #10                                   <== NOT EXECUTED
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
   3c6e4:	e58d9004 	str	r9, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c6e8:	e58db014 	str	fp, [sp, #20]                                 <== NOT EXECUTED
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
   3c6ec:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
  map_index     = rtems_rfs_bitmap_map_index (test_bit);              
  map_offset    = rtems_rfs_bitmap_map_offset (test_bit);             
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
  search_offset = rtems_rfs_bitmap_map_offset (map_index);            
                                                                      
  search_bits = &control->search_bits[search_index];                  
   3c6f0:	e0828108 	add	r8, r2, r8, lsl #2                            <== NOT EXECUTED
  map_bits    = &map[map_index];                                      
   3c6f4:	e0877106 	add	r7, r7, r6, lsl #2                            <== NOT EXECUTED
    end_bit = 0;                                                      
  else if (end_bit >= control->size)                                  
    end_bit = control->size - 1;                                      
                                                                      
  map_index     = rtems_rfs_bitmap_map_index (test_bit);              
  map_offset    = rtems_rfs_bitmap_map_offset (test_bit);             
   3c6f8:	e203101f 	and	r1, r3, #31                                   <== NOT EXECUTED
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
  search_offset = rtems_rfs_bitmap_map_offset (map_index);            
   3c6fc:	e206201f 	and	r2, r6, #31                                   <== NOT EXECUTED
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
   3c700:	e1a0a005 	mov	sl, r5                                        <== NOT EXECUTED
    /*                                                                
     * If any bit is clear find that bit and then search the map element. If
     * all bits are set there are no map bits so move to the next search
     * element.                                                       
     */                                                               
    if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
   3c704:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
   3c708:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c70c:	10865004 	addne	r5, r6, r4                                  <== NOT EXECUTED
   3c710:	11a05285 	lslne	r5, r5, #5                                  <== NOT EXECUTED
    /*                                                                
     * If any bit is clear find that bit and then search the map element. If
     * all bits are set there are no map bits so move to the next search
     * element.                                                       
     */                                                               
    if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
   3c714:	1a000038 	bne	3c7fc <T.57+0x184>                            <== NOT EXECUTED
   3c718:	ea00003a 	b	3c808 <T.57+0x190>                              <== NOT EXECUTED
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
   3c71c:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
   3c720:	e1a09219 	lsl	r9, r9, r2                                    <== NOT EXECUTED
    if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
    {                                                                 
      while ((search_offset >= 0)                                     
             && (search_offset < rtems_rfs_bitmap_element_bits ()))   
      {                                                               
        if (!rtems_rfs_bitmap_test (*search_bits, search_offset))     
   3c724:	e1190000 	tst	r9, r0                                        <== NOT EXECUTED
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
   3c728:	e58d9000 	str	r9, [sp]                                      <== NOT EXECUTED
    if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
    {                                                                 
      while ((search_offset >= 0)                                     
             && (search_offset < rtems_rfs_bitmap_element_bits ()))   
      {                                                               
        if (!rtems_rfs_bitmap_test (*search_bits, search_offset))     
   3c72c:	1a00001d 	bne	3c7a8 <T.57+0x130>                            <== NOT EXECUTED
   3c730:	ea00001e 	b	3c7b0 <T.57+0x138>                              <== NOT EXECUTED
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
   3c734:	e3a0b001 	mov	fp, #1                                        <== NOT EXECUTED
   3c738:	e1a0911b 	lsl	r9, fp, r1                                    <== NOT EXECUTED
           * found. We may find none are spare if searching up from the seed.
           */                                                         
          while ((map_offset >= 0)                                    
                 && (map_offset < rtems_rfs_bitmap_element_bits ()))  
          {                                                           
            if (!rtems_rfs_bitmap_test (*map_bits, map_offset))       
   3c73c:	e597b000 	ldr	fp, [r7]                                      <== NOT EXECUTED
   3c740:	e119000b 	tst	r9, fp                                        <== NOT EXECUTED
   3c744:	0a000013 	beq	3c798 <T.57+0x120>                            <== NOT EXECUTED
 */                                                                   
static rtems_rfs_bitmap_element                                       
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,                
                      rtems_rfs_bitmap_element bits)                  
{                                                                     
  return RTEMS_RFS_BITMAP_SET_BITS (target, bits);                    
   3c748:	e1cb9009 	bic	r9, fp, r9                                    <== NOT EXECUTED
          while ((map_offset >= 0)                                    
                 && (map_offset < rtems_rfs_bitmap_element_bits ()))  
          {                                                           
            if (!rtems_rfs_bitmap_test (*map_bits, map_offset))       
            {                                                         
              *map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
   3c74c:	e5879000 	str	r9, [r7]                                      <== NOT EXECUTED
              if (rtems_rfs_bitmap_match(*map_bits,                   
   3c750:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
                                         RTEMS_RFS_BITMAP_ELEMENT_SET))
                *search_bits = rtems_rfs_bitmap_set (*search_bits,    
   3c754:	05982000 	ldreq	r2, [r8]                                    <== NOT EXECUTED
   3c758:	059d0000 	ldreq	r0, [sp]                                    <== NOT EXECUTED
   3c75c:	01c22000 	biceq	r2, r2, r0                                  <== NOT EXECUTED
   3c760:	05882000 	streq	r2, [r8]                                    <== NOT EXECUTED
                                                     1 << search_offset);
              control->free--;                                        
   3c764:	e59a0010 	ldr	r0, [sl, #16]                                 <== NOT EXECUTED
              *bit = test_bit;                                        
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
   3c768:	e59a1000 	ldr	r1, [sl]                                      <== NOT EXECUTED
              if (rtems_rfs_bitmap_match(*map_bits,                   
                                         RTEMS_RFS_BITMAP_ELEMENT_SET))
                *search_bits = rtems_rfs_bitmap_set (*search_bits,    
                                                     1 << search_offset);
              control->free--;                                        
              *bit = test_bit;                                        
   3c76c:	e28d9008 	add	r9, sp, #8                                    <== NOT EXECUTED
   3c770:	e8990a00 	ldm	r9, {r9, fp}                                  <== NOT EXECUTED
              *map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
              if (rtems_rfs_bitmap_match(*map_bits,                   
                                         RTEMS_RFS_BITMAP_ELEMENT_SET))
                *search_bits = rtems_rfs_bitmap_set (*search_bits,    
                                                     1 << search_offset);
              control->free--;                                        
   3c774:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
              *bit = test_bit;                                        
              *found = true;                                          
   3c778:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
              *map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
              if (rtems_rfs_bitmap_match(*map_bits,                   
                                         RTEMS_RFS_BITMAP_ELEMENT_SET))
                *search_bits = rtems_rfs_bitmap_set (*search_bits,    
                                                     1 << search_offset);
              control->free--;                                        
   3c77c:	e58a0010 	str	r0, [sl, #16]                                 <== NOT EXECUTED
              *bit = test_bit;                                        
              *found = true;                                          
   3c780:	e5cb2000 	strb	r2, [fp]                                     <== NOT EXECUTED
   3c784:	e1a0500a 	mov	r5, sl                                        <== NOT EXECUTED
              if (rtems_rfs_bitmap_match(*map_bits,                   
                                         RTEMS_RFS_BITMAP_ELEMENT_SET))
                *search_bits = rtems_rfs_bitmap_set (*search_bits,    
                                                     1 << search_offset);
              control->free--;                                        
              *bit = test_bit;                                        
   3c788:	e5893000 	str	r3, [r9]                                      <== NOT EXECUTED
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
   3c78c:	e5c12000 	strb	r2, [r1]                                     <== NOT EXECUTED
   3c790:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3c794:	ea000039 	b	3c880 <T.57+0x208>                              <== NOT EXECUTED
              return 0;                                               
            }                                                         
                                                                      
            if (test_bit == end_bit)                                  
   3c798:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c79c:	0a000003 	beq	3c7b0 <T.57+0x138>                            <== NOT EXECUTED
   3c7a0:	e0811004 	add	r1, r1, r4                                    <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c7a4:	e0833004 	add	r3, r3, r4                                    <== NOT EXECUTED
        {                                                             
          /*                                                          
           * Find the clear bit in the map. Update the search map and map if
           * found. We may find none are spare if searching up from the seed.
           */                                                         
          while ((map_offset >= 0)                                    
   3c7a8:	e351001f 	cmp	r1, #31                                       <== NOT EXECUTED
   3c7ac:	9affffe0 	bls	3c734 <T.57+0xbc>                             <== NOT EXECUTED
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
        map_index += direction;                                       
        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
   3c7b0:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3c7b4:	d3a0101f 	movle	r1, #31                                     <== NOT EXECUTED
   3c7b8:	c3a01000 	movgt	r1, #0                                      <== NOT EXECUTED
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
   3c7bc:	e59d9010 	ldr	r9, [sp, #16]                                 <== NOT EXECUTED
                                                                      
        map_bits  += direction;                                       
        map_index += direction;                                       
        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
   3c7c0:	e0813005 	add	r3, r1, r5                                    <== NOT EXECUTED
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
   3c7c4:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c7c8:	c3a09000 	movgt	r9, #0                                      <== NOT EXECUTED
   3c7cc:	d2099001 	andle	r9, r9, #1                                  <== NOT EXECUTED
   3c7d0:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
   3c7d4:	e59d9004 	ldr	r9, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   3c7d8:	e0866004 	add	r6, r6, r4                                    <== NOT EXECUTED
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
   3c7dc:	e0877009 	add	r7, r7, r9                                    <== NOT EXECUTED
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
   3c7e0:	1a000014 	bne	3c838 <T.57+0x1c0>                            <== NOT EXECUTED
   3c7e4:	e59db014 	ldr	fp, [sp, #20]                                 <== NOT EXECUTED
   3c7e8:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c7ec:	a3540000 	cmpge	r4, #0                                      <== NOT EXECUTED
   3c7f0:	e085500b 	add	r5, r5, fp                                    <== NOT EXECUTED
   3c7f4:	ca00000f 	bgt	3c838 <T.57+0x1c0>                            <== NOT EXECUTED
   3c7f8:	e0822004 	add	r2, r2, r4                                    <== NOT EXECUTED
     * all bits are set there are no map bits so move to the next search
     * element.                                                       
     */                                                               
    if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
    {                                                                 
      while ((search_offset >= 0)                                     
   3c7fc:	e352001f 	cmp	r2, #31                                       <== NOT EXECUTED
   3c800:	9affffc5 	bls	3c71c <T.57+0xa4>                             <== NOT EXECUTED
   3c804:	ea00000b 	b	3c838 <T.57+0x1c0>                              <== NOT EXECUTED
       * Align test_bit either up or down depending on the direction to next 32
       * bit boundary.                                                
       */                                                             
      rtems_rfs_bitmap_bit bits_skipped;                              
      test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);       
      if (direction > 0)                                              
   3c808:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
        bits_skipped = search_offset + 1;                             
        /*                                                            
         * Need to remove 1 for the rounding up. The above rounds down and
         * adds 1. Remember the logic is for subtraction.             
         */                                                           
        test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
   3c80c:	d1e01282 	mvnle	r1, r2, lsl #5                              <== NOT EXECUTED
       */                                                             
      rtems_rfs_bitmap_bit bits_skipped;                              
      test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);       
      if (direction > 0)                                              
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
   3c810:	c2622020 	rsbgt	r2, r2, #32                                 <== NOT EXECUTED
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
        map_offset = 0;                                               
      }                                                               
      else                                                            
      {                                                               
        bits_skipped = search_offset + 1;                             
   3c814:	d2822001 	addle	r2, r2, #1                                  <== NOT EXECUTED
      rtems_rfs_bitmap_bit bits_skipped;                              
      test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);       
      if (direction > 0)                                              
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
   3c818:	c1a01000 	movgt	r1, r0                                      <== NOT EXECUTED
         * adds 1. Remember the logic is for subtraction.             
         */                                                           
        test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
      }                                                               
      map_bits += direction * bits_skipped;                           
   3c81c:	e0000294 	mul	r0, r4, r2                                    <== NOT EXECUTED
       *                                                              
       * Align test_bit either up or down depending on the direction to next 32
       * bit boundary.                                                
       */                                                             
      rtems_rfs_bitmap_bit bits_skipped;                              
      test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);       
   3c820:	e3c3301f 	bic	r3, r3, #31                                   <== NOT EXECUTED
        bits_skipped = search_offset + 1;                             
        /*                                                            
         * Need to remove 1 for the rounding up. The above rounds down and
         * adds 1. Remember the logic is for subtraction.             
         */                                                           
        test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
   3c824:	d0813003 	addle	r3, r1, r3                                  <== NOT EXECUTED
      rtems_rfs_bitmap_bit bits_skipped;                              
      test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);       
      if (direction > 0)                                              
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
   3c828:	c0833282 	addgt	r3, r3, r2, lsl #5                          <== NOT EXECUTED
        bits_skipped = search_offset + 1;                             
        /*                                                            
         * Need to remove 1 for the rounding up. The above rounds down and
         * adds 1. Remember the logic is for subtraction.             
         */                                                           
        test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
   3c82c:	d3a0101f 	movle	r1, #31                                     <== NOT EXECUTED
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
   3c830:	e0866000 	add	r6, r6, r0                                    <== NOT EXECUTED
         * adds 1. Remember the logic is for subtraction.             
         */                                                           
        test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
      }                                                               
      map_bits += direction * bits_skipped;                           
   3c834:	e0877100 	add	r7, r7, r0, lsl #2                            <== NOT EXECUTED
                                                                      
    search_bits  += direction;                                        
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
   3c838:	e59d0010 	ldr	r0, [sp, #16]                                 <== NOT EXECUTED
   3c83c:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c840:	b3a00000 	movlt	r0, #0                                      <== NOT EXECUTED
   3c844:	a2000001 	andge	r0, r0, #1                                  <== NOT EXECUTED
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
   3c848:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3c84c:	d3a0201f 	movle	r2, #31                                     <== NOT EXECUTED
   3c850:	c3a02000 	movgt	r2, #0                                      <== NOT EXECUTED
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
   3c854:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
   3c858:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
   3c85c:	e0888000 	add	r8, r8, r0                                    <== NOT EXECUTED
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
   3c860:	1affffa7 	bne	3c704 <T.57+0x8c>                             <== NOT EXECUTED
   3c864:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c868:	c3a00000 	movgt	r0, #0                                      <== NOT EXECUTED
   3c86c:	d3a00001 	movle	r0, #1                                      <== NOT EXECUTED
   3c870:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3c874:	d3a00000 	movle	r0, #0                                      <== NOT EXECUTED
   3c878:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c87c:	1affffa0 	bne	3c704 <T.57+0x8c>                             <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   3c880:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
   3c884:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00000448 <_Barrier_Manager_initialization>: #include <rtems/score/object.h> #include <rtems/rtems/barrier.h> void _Barrier_Manager_initialization(void) { }
     448:	e12fff1e 	bx	lr                                             
                                                                      

0000ad80 <_CORE_mutex_Seize_interrupt_trylock>: { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing;
    ad80:	e59f3110 	ldr	r3, [pc, #272]	; ae98 <_CORE_mutex_Seize_interrupt_trylock+0x118>
    ad84:	e5933000 	ldr	r3, [r3]                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
    ad88:	e3a02000 	mov	r2, #0                                        
    ad8c:	e5832034 	str	r2, [r3, #52]	; 0x34                          
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
    ad90:	e590c050 	ldr	ip, [r0, #80]	; 0x50                          
    ad94:	e15c0002 	cmp	ip, r2                                        
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)                 
int _CORE_mutex_Seize_interrupt_trylock(                              
  CORE_mutex_Control  *the_mutex,                                     
  ISR_Level           *level_p                                        
)                                                                     
{                                                                     
    ad98:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
    ad9c:	0a00002a 	beq	ae4c <_CORE_mutex_Seize_interrupt_trylock+0xcc>
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
    ada0:	e5802050 	str	r2, [r0, #80]	; 0x50                          
 */                                                                   
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(            
  CORE_mutex_Attributes *the_attribute                                
)                                                                     
{                                                                     
  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
    ada4:	e5902048 	ldr	r2, [r0, #72]	; 0x48                          
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
    the_mutex->holder     = executing;                                
    the_mutex->holder_id  = executing->Object.id;                     
    ada8:	e593c008 	ldr	ip, [r3, #8]                                  
    the_mutex->nest_count = 1;                                        
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
    adac:	e3520002 	cmp	r2, #2                                        
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
    the_mutex->holder     = executing;                                
    the_mutex->holder_id  = executing->Object.id;                     
    adb0:	e580c060 	str	ip, [r0, #96]	; 0x60                          
    the_mutex->nest_count = 1;                                        
    adb4:	e3a0c001 	mov	ip, #1                                        
    adb8:	e580c054 	str	ip, [r0, #84]	; 0x54                          
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
    the_mutex->holder     = executing;                                
    adbc:	e580305c 	str	r3, [r0, #92]	; 0x5c                          
    the_mutex->holder_id  = executing->Object.id;                     
    the_mutex->nest_count = 1;                                        
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
    adc0:	0a000001 	beq	adcc <_CORE_mutex_Seize_interrupt_trylock+0x4c>
    adc4:	e3520003 	cmp	r2, #3                                        
    adc8:	1a00002c 	bne	ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
    adcc:	e593c01c 	ldr	ip, [r3, #28]                                 
    }                                                                 
                                                                      
    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
    add0:	e3520003 	cmp	r2, #3                                        
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
    add4:	e28c2001 	add	r2, ip, #1                                    
    add8:	e583201c 	str	r2, [r3, #28]                                 
    }                                                                 
                                                                      
    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
    addc:	1a000027 	bne	ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
       */                                                             
    {                                                                 
      Priority_Control  ceiling;                                      
      Priority_Control  current;                                      
                                                                      
      ceiling = the_mutex->Attributes.priority_ceiling;               
    ade0:	e590204c 	ldr	r2, [r0, #76]	; 0x4c                          
      current = executing->current_priority;                          
    ade4:	e593c014 	ldr	ip, [r3, #20]                                 
      if ( current == ceiling ) {                                     
    ade8:	e15c0002 	cmp	ip, r2                                        
    adec:	0a000023 	beq	ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
      }                                                               
                                                                      
      if ( current > ceiling ) {                                      
    adf0:	9a00000b 	bls	ae24 <_CORE_mutex_Seize_interrupt_trylock+0xa4>
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
    adf4:	e59f30a0 	ldr	r3, [pc, #160]	; ae9c <_CORE_mutex_Seize_interrupt_trylock+0x11c>
    adf8:	e5932000 	ldr	r2, [r3]                                      
    adfc:	e2822001 	add	r2, r2, #1                                    
    ae00:	e5832000 	str	r2, [r3]                                      
    ae04:	e5913000 	ldr	r3, [r1]                                      
    ae08:	e129f003 	msr	CPSR_fc, r3                                   
        _Thread_Disable_dispatch();                                   
        _ISR_Enable( *level_p );                                      
        _Thread_Change_priority(                                      
    ae0c:	e3a02000 	mov	r2, #0                                        
    ae10:	e590104c 	ldr	r1, [r0, #76]	; 0x4c                          
    ae14:	e590005c 	ldr	r0, [r0, #92]	; 0x5c                          
    ae18:	ebffef45 	bl	6b34 <_Thread_Change_priority>                 
          the_mutex->holder,                                          
          the_mutex->Attributes.priority_ceiling,                     
         false                                                        
        );                                                            
        _Thread_Enable_dispatch();                                    
    ae1c:	ebfff0a5 	bl	70b8 <_Thread_Enable_dispatch>                 
    ae20:	ea000018 	b	ae88 <_CORE_mutex_Seize_interrupt_trylock+0x108>
        return 0;                                                     
      }                                                               
      /* if ( current < ceiling ) */ {                                
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
    ae24:	e3a02006 	mov	r2, #6                                        
    ae28:	e5832034 	str	r2, [r3, #52]	; 0x34                          
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;                  
        the_mutex->nest_count = 0;     /* undo locking above */       
    ae2c:	e3a02000 	mov	r2, #0                                        
    ae30:	e5802054 	str	r2, [r0, #84]	; 0x54                          
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
      }                                                               
      /* if ( current < ceiling ) */ {                                
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;                  
    ae34:	e2822001 	add	r2, r2, #1                                    
    ae38:	e5802050 	str	r2, [r0, #80]	; 0x50                          
        the_mutex->nest_count = 0;     /* undo locking above */       
        executing->resource_count--;   /* undo locking above */       
    ae3c:	e593201c 	ldr	r2, [r3, #28]                                 
    ae40:	e2422001 	sub	r2, r2, #1                                    
    ae44:	e583201c 	str	r2, [r3, #28]                                 
    ae48:	ea00000c 	b	ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
  /*                                                                  
   *  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 ) ) {                  
    ae4c:	e590205c 	ldr	r2, [r0, #92]	; 0x5c                          
    ae50:	e1520003 	cmp	r2, r3                                        
    ae54:	1a00000d 	bne	ae90 <_CORE_mutex_Seize_interrupt_trylock+0x110>
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {          
    ae58:	e5903040 	ldr	r3, [r0, #64]	; 0x40                          
    ae5c:	e3530000 	cmp	r3, #0                                        
      case CORE_MUTEX_NESTING_ACQUIRES:                               
        the_mutex->nest_count++;                                      
    ae60:	05903054 	ldreq	r3, [r0, #84]	; 0x54                        
    ae64:	02833001 	addeq	r3, r3, #1                                  
    ae68:	05803054 	streq	r3, [r0, #84]	; 0x54                        
   *  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 ) {          
    ae6c:	0a000003 	beq	ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
    ae70:	e3530001 	cmp	r3, #1                                        
    ae74:	1a000005 	bne	ae90 <_CORE_mutex_Seize_interrupt_trylock+0x110>
      case CORE_MUTEX_NESTING_ACQUIRES:                               
        the_mutex->nest_count++;                                      
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
      case CORE_MUTEX_NESTING_IS_ERROR:                               
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
    ae78:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
    ae7c:	e5823034 	str	r3, [r2, #52]	; 0x34                          <== NOT EXECUTED
    ae80:	e5913000 	ldr	r3, [r1]                                      
    ae84:	e129f003 	msr	CPSR_fc, r3                                   
    ae88:	e3a00000 	mov	r0, #0                                        
    ae8c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    ae90:	e3a00001 	mov	r0, #1                                        
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}                                                                     
    ae94:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

0000044c <_Dual_ported_memory_Manager_initialization>: #include <rtems/rtems/types.h> #include <rtems/rtems/dpmem.h> void _Dual_ported_memory_Manager_initialization(void) { }
     44c:	e12fff1e 	bx	lr                                             
                                                                      

00000450 <_Event_Manager_initialization>: #include <rtems/score/thread.h> #include <rtems/score/interr.h> void _Event_Manager_initialization(void) { }
     450:	e12fff1e 	bx	lr                                             
                                                                      

0000046c <_Extension_Manager_initialization>: #include <rtems/extension.h> #include <rtems/score/interr.h> void _Extension_Manager_initialization(void) { }
     46c:	e12fff1e 	bx	lr                                             
                                                                      

00000454 <_Message_queue_Manager_initialization>: #include <rtems/score/wkspace.h> #include <rtems/score/interr.h> void _Message_queue_Manager_initialization(void) { }
     454:	e12fff1e 	bx	lr                                             
                                                                      

00000458 <_Partition_Manager_initialization>: #include <rtems/score/thread.h> #include <rtems/score/interr.h> void _Partition_Manager_initialization(void) { }
     458:	e12fff1e 	bx	lr                                             
                                                                      

00000468 <_Rate_monotonic_Manager_initialization>: #include <rtems/rtems/types.h> #include <rtems/rtems/ratemon.h> void _Rate_monotonic_Manager_initialization(void) { }
     468:	e12fff1e 	bx	lr                                             
                                                                      

0000045c <_Region_Manager_initialization>: #include <rtems/score/thread.h> #include <rtems/score/interr.h> void _Region_Manager_initialization(void) { }
     45c:	e12fff1e 	bx	lr                                             
                                                                      

00007614 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) {
    7614:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
  Priority_Control     priority;                                      
  States_Control       block_state;                                   
                                                                      
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
    7618:	e5913014 	ldr	r3, [r1, #20]                                 
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    761c:	e281503c 	add	r5, r1, #60	; 0x3c                            
    7620:	e5815038 	str	r5, [r1, #56]	; 0x38                          
  the_chain->permanent_null = NULL;                                   
    7624:	e3a05000 	mov	r5, #0                                        
  the_chain->last           = _Chain_Head(the_chain);                 
    7628:	e281c038 	add	ip, r1, #56	; 0x38                            
  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 ) )                  
    762c:	e3130020 	tst	r3, #32                                       
                                                                      
  _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 ];  
    7630:	e1a04323 	lsr	r4, r3, #6                                    
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
    7634:	e581503c 	str	r5, [r1, #60]	; 0x3c                          
    7638:	e285500c 	add	r5, r5, #12                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    763c:	e581c040 	str	ip, [r1, #64]	; 0x40                          
  block_state  = the_thread_queue->state;                             
    7640:	e5907038 	ldr	r7, [r0, #56]	; 0x38                          
                                                                      
  _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 ];  
    7644:	e02c0495 	mla	ip, r5, r4, r0                                
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
    7648:	159f8154 	ldrne	r8, [pc, #340]	; 77a4 <_Thread_queue_Enqueue_priority+0x190>
  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 ) )                  
    764c:	1a000023 	bne	76e0 <_Thread_queue_Enqueue_priority+0xcc>    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    7650:	e28c8004 	add	r8, ip, #4                                    
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    7654:	e10f5000 	mrs	r5, CPSR                                      
    7658:	e3854080 	orr	r4, r5, #128	; 0x80                           
    765c:	e129f004 	msr	CPSR_fc, r4                                   
    goto restart_reverse_search;                                      
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->first;                   
    7660:	e3e06000 	mvn	r6, #0                                        
    7664:	e59c4000 	ldr	r4, [ip]                                      
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
    7668:	ea00000b 	b	769c <_Thread_queue_Enqueue_priority+0x88>      
    search_priority = search_thread->current_priority;                
    766c:	e5946014 	ldr	r6, [r4, #20]                                 
    if ( priority <= search_priority )                                
    7670:	e1530006 	cmp	r3, r6                                        
    7674:	9a00000a 	bls	76a4 <_Thread_queue_Enqueue_priority+0x90>    
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  asm volatile (                                                      
    7678:	e10fa000 	mrs	sl, CPSR                                      
    767c:	e129f005 	msr	CPSR_fc, r5                                   
    7680:	e129f00a 	msr	CPSR_fc, sl                                   
    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) ) {
    7684:	e594a010 	ldr	sl, [r4, #16]                                 
    7688:	e117000a 	tst	r7, sl                                        
    768c:	1a000001 	bne	7698 <_Thread_queue_Enqueue_priority+0x84>    
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    7690:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
    7694:	eaffffee 	b	7654 <_Thread_queue_Enqueue_priority+0x40>      <== NOT EXECUTED
      _ISR_Enable( level );                                           
      goto restart_forward_search;                                    
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
    7698:	e5944000 	ldr	r4, [r4]                                      
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->first;                   
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
    769c:	e1540008 	cmp	r4, r8                                        
    76a0:	1afffff1 	bne	766c <_Thread_queue_Enqueue_priority+0x58>    
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
    76a4:	e590c030 	ldr	ip, [r0, #48]	; 0x30                          
    76a8:	e35c0001 	cmp	ip, #1                                        
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->first;                   
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
    76ac:	e1a0c005 	mov	ip, r5                                        
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
    76b0:	1a000038 	bne	7798 <_Thread_queue_Enqueue_priority+0x184>   
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
                                                                      
  if ( priority == search_priority )                                  
    76b4:	e1530006 	cmp	r3, r6                                        
                                                                      
  if ( the_thread_queue->sync_state !=                                
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
    76b8:	e3a03000 	mov	r3, #0                                        
    76bc:	e5803030 	str	r3, [r0, #48]	; 0x30                          
                                                                      
  if ( priority == search_priority )                                  
    76c0:	0a00002a 	beq	7770 <_Thread_queue_Enqueue_priority+0x15c>   
    goto equal_priority;                                              
                                                                      
  search_node   = (Chain_Node *) search_thread;                       
  previous_node = search_node->previous;                              
    76c4:	e5943004 	ldr	r3, [r4, #4]                                  
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
    76c8:	e5814000 	str	r4, [r1]                                      
  the_node->previous     = previous_node;                             
    76cc:	e5813004 	str	r3, [r1, #4]                                  
  previous_node->next    = the_node;                                  
  search_node->previous  = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
    76d0:	e5810044 	str	r0, [r1, #68]	; 0x44                          
  previous_node = search_node->previous;                              
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
  the_node->previous     = previous_node;                             
  previous_node->next    = the_node;                                  
    76d4:	e5831000 	str	r1, [r3]                                      
  search_node->previous  = the_node;                                  
    76d8:	e5841004 	str	r1, [r4, #4]                                  
    76dc:	ea000021 	b	7768 <_Thread_queue_Enqueue_priority+0x154>     
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
    76e0:	e5d86000 	ldrb	r6, [r8]                                     
    76e4:	e2866001 	add	r6, r6, #1                                    
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    76e8:	e10f5000 	mrs	r5, CPSR                                      
    76ec:	e3854080 	orr	r4, r5, #128	; 0x80                           
    76f0:	e129f004 	msr	CPSR_fc, r4                                   
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->last;                    
    76f4:	e59c4008 	ldr	r4, [ip, #8]                                  
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
    76f8:	ea00000b 	b	772c <_Thread_queue_Enqueue_priority+0x118>     
    search_priority = search_thread->current_priority;                
    76fc:	e5946014 	ldr	r6, [r4, #20]                                 
    if ( priority >= search_priority )                                
    7700:	e1530006 	cmp	r3, r6                                        
    7704:	2a00000a 	bcs	7734 <_Thread_queue_Enqueue_priority+0x120>   
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  asm volatile (                                                      
    7708:	e10fa000 	mrs	sl, CPSR                                      
    770c:	e129f005 	msr	CPSR_fc, r5                                   
    7710:	e129f00a 	msr	CPSR_fc, sl                                   
    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) ) {
    7714:	e594a010 	ldr	sl, [r4, #16]                                 
    7718:	e117000a 	tst	r7, sl                                        
    771c:	1a000001 	bne	7728 <_Thread_queue_Enqueue_priority+0x114>   
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    7720:	e129f005 	msr	CPSR_fc, r5                                   
    7724:	eaffffed 	b	76e0 <_Thread_queue_Enqueue_priority+0xcc>      
      _ISR_Enable( level );                                           
      goto restart_reverse_search;                                    
    }                                                                 
    search_thread = (Thread_Control *)                                
    7728:	e5944004 	ldr	r4, [r4, #4]                                  
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->last;                    
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
    772c:	e154000c 	cmp	r4, ip                                        
    7730:	1afffff1 	bne	76fc <_Thread_queue_Enqueue_priority+0xe8>    
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
    7734:	e590c030 	ldr	ip, [r0, #48]	; 0x30                          
    7738:	e35c0001 	cmp	ip, #1                                        
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) header->last;                    
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
    773c:	e1a0c005 	mov	ip, r5                                        
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
    7740:	1a000014 	bne	7798 <_Thread_queue_Enqueue_priority+0x184>   
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
                                                                      
  if ( priority == search_priority )                                  
    7744:	e1530006 	cmp	r3, r6                                        
                                                                      
  if ( the_thread_queue->sync_state !=                                
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
    7748:	e3a03000 	mov	r3, #0                                        
    774c:	e5803030 	str	r3, [r0, #48]	; 0x30                          
                                                                      
  if ( priority == search_priority )                                  
    7750:	0a000006 	beq	7770 <_Thread_queue_Enqueue_priority+0x15c>   
    goto equal_priority;                                              
                                                                      
  search_node = (Chain_Node *) search_thread;                         
  next_node   = search_node->next;                                    
    7754:	e5943000 	ldr	r3, [r4]                                      
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  the_node->previous      = search_node;                              
    7758:	e8810018 	stm	r1, {r3, r4}                                  
  search_node->next       = the_node;                                 
  next_node->previous    = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
    775c:	e5810044 	str	r0, [r1, #68]	; 0x44                          
  next_node   = search_node->next;                                    
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  the_node->previous      = search_node;                              
  search_node->next       = the_node;                                 
    7760:	e5841000 	str	r1, [r4]                                      
  next_node->previous    = the_node;                                  
    7764:	e5831004 	str	r1, [r3, #4]                                  
    7768:	e129f005 	msr	CPSR_fc, r5                                   
    776c:	ea000007 	b	7790 <_Thread_queue_Enqueue_priority+0x17c>     
    7770:	e284403c 	add	r4, r4, #60	; 0x3c                            
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
equal_priority:               /* add at end of priority group */      
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );        
  previous_node = search_node->previous;                              
    7774:	e5943004 	ldr	r3, [r4, #4]                                  
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
    7778:	e5814000 	str	r4, [r1]                                      
  the_node->previous     = previous_node;                             
    777c:	e5813004 	str	r3, [r1, #4]                                  
  previous_node->next    = the_node;                                  
  search_node->previous  = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
    7780:	e5810044 	str	r0, [r1, #68]	; 0x44                          
  previous_node = search_node->previous;                              
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
  the_node->previous     = previous_node;                             
  previous_node->next    = the_node;                                  
    7784:	e5831000 	str	r1, [r3]                                      
  search_node->previous  = the_node;                                  
    7788:	e5841004 	str	r1, [r4, #4]                                  
    778c:	e129f00c 	msr	CPSR_fc, ip                                   
    7790:	e3a00001 	mov	r0, #1                                        
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
    7794:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
   *  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;                                                   
    7798:	e582c000 	str	ip, [r2]                                      
  return the_thread_queue->sync_state;                                
    779c:	e5900030 	ldr	r0, [r0, #48]	; 0x30                          
}                                                                     
    77a0:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

00000464 <_Timer_Manager_initialization>: #include <rtems/rtems/types.h> #include <rtems/rtems/timer.h> void _Timer_Manager_initialization(void) { }
     464:	e12fff1e 	bx	lr                                             
                                                                      

00015138 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) {
   15138:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
   1513c:	e24dd020 	sub	sp, sp, #32                                   
   15140:	e28d3014 	add	r3, sp, #20                                   
   15144:	e28d5008 	add	r5, sp, #8                                    
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
   15148:	e3a09000 	mov	r9, #0                                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
   1514c:	e283a004 	add	sl, r3, #4                                    
   15150:	e2858004 	add	r8, r5, #4                                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   15154:	e58d301c 	str	r3, [sp, #28]                                 
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
   15158:	e2802008 	add	r2, r0, #8                                    
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
   1515c:	e2803040 	add	r3, r0, #64	; 0x40                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   15160:	e58da014 	str	sl, [sp, #20]                                 
  the_chain->permanent_null = NULL;                                   
   15164:	e58d9018 	str	r9, [sp, #24]                                 
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   15168:	e58d8008 	str	r8, [sp, #8]                                  
  the_chain->permanent_null = NULL;                                   
   1516c:	e58d900c 	str	r9, [sp, #12]                                 
  the_chain->last           = _Chain_Head(the_chain);                 
   15170:	e58d5010 	str	r5, [sp, #16]                                 
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
   15174:	e58d2004 	str	r2, [sp, #4]                                  
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
   15178:	e58d3000 	str	r3, [sp]                                      
 *  @a arg points to the corresponding timer server control block.    
 */                                                                   
static rtems_task _Timer_server_Body(                                 
  rtems_task_argument arg                                             
)                                                                     
{                                                                     
   1517c:	e1a04000 	mov	r4, r0                                        
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
   15180:	e280b030 	add	fp, r0, #48	; 0x30                            
    /*                                                                
     *  This path is for normal forward movement and cases where the  
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   15184:	e2807068 	add	r7, r0, #104	; 0x68                           
{                                                                     
  /*                                                                  
   *  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;                                    
   15188:	e28d2014 	add	r2, sp, #20                                   
   1518c:	e5842078 	str	r2, [r4, #120]	; 0x78                         
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
   15190:	e59f2168 	ldr	r2, [pc, #360]	; 15300 <_Timer_server_Body+0x1c8>
   15194:	e5923000 	ldr	r3, [r2]                                      
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
   15198:	e594103c 	ldr	r1, [r4, #60]	; 0x3c                          
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
   1519c:	e1a02005 	mov	r2, r5                                        
   151a0:	e0611003 	rsb	r1, r1, r3                                    
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
   151a4:	e584303c 	str	r3, [r4, #60]	; 0x3c                          
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
   151a8:	e1a0000b 	mov	r0, fp                                        
   151ac:	eb000ff2 	bl	1917c <_Watchdog_Adjust_to_chain>              
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
   151b0:	e59f314c 	ldr	r3, [pc, #332]	; 15304 <_Timer_server_Body+0x1cc>
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;         
   151b4:	e5942074 	ldr	r2, [r4, #116]	; 0x74                         
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
   151b8:	e5936000 	ldr	r6, [r3]                                      
  /*                                                                  
   *  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 ) {                                   
   151bc:	e1560002 	cmp	r6, r2                                        
   151c0:	9a000004 	bls	151d8 <_Timer_server_Body+0xa0>               
    /*                                                                
     *  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 );
   151c4:	e0621006 	rsb	r1, r2, r6                                    
   151c8:	e1a00007 	mov	r0, r7                                        
   151cc:	e1a02005 	mov	r2, r5                                        
   151d0:	eb000fe9 	bl	1917c <_Watchdog_Adjust_to_chain>              
   151d4:	ea000003 	b	151e8 <_Timer_server_Body+0xb0>                 
     /*                                                               
      *  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 ); 
   151d8:	30662002 	rsbcc	r2, r6, r2                                  
   151dc:	31a00007 	movcc	r0, r7                                      
   151e0:	33a01001 	movcc	r1, #1                                      
   151e4:	3b000fbc 	blcc	190dc <_Watchdog_Adjust>                     
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
   151e8:	e5846074 	str	r6, [r4, #116]	; 0x74                         
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
   151ec:	e5940078 	ldr	r0, [r4, #120]	; 0x78                         
   151f0:	eb000221 	bl	15a7c <_Chain_Get>                             
                                                                      
    if ( timer == NULL ) {                                            
   151f4:	e2501000 	subs	r1, r0, #0                                   
   151f8:	0a00000a 	beq	15228 <_Timer_server_Body+0xf0>               
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
   151fc:	e5913038 	ldr	r3, [r1, #56]	; 0x38                          
   15200:	e3530001 	cmp	r3, #1                                        
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
   15204:	02811010 	addeq	r1, r1, #16                                 
   15208:	01a0000b 	moveq	r0, fp                                      
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
   1520c:	0a000003 	beq	15220 <_Timer_server_Body+0xe8>               
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
   15210:	e3530003 	cmp	r3, #3                                        
   15214:	1afffff4 	bne	151ec <_Timer_server_Body+0xb4>               
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
   15218:	e2811010 	add	r1, r1, #16                                   
   1521c:	e1a00007 	mov	r0, r7                                        
   15220:	eb001002 	bl	19230 <_Watchdog_Insert>                       
   15224:	eafffff0 	b	151ec <_Timer_server_Body+0xb4>                 
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
   15228:	e10f3000 	mrs	r3, CPSR                                      
   1522c:	e3832080 	orr	r2, r3, #128	; 0x80                           
   15230:	e129f002 	msr	CPSR_fc, r2                                   
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
   15234:	e59d2014 	ldr	r2, [sp, #20]                                 
   15238:	e152000a 	cmp	r2, sl                                        
   1523c:	1a000005 	bne	15258 <_Timer_server_Body+0x120>              
      ts->insert_chain = NULL;                                        
   15240:	e5841078 	str	r1, [r4, #120]	; 0x78                         
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
   15244:	e129f003 	msr	CPSR_fc, r3                                   
  _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 ) ) {                          
   15248:	e59d3008 	ldr	r3, [sp, #8]                                  
   1524c:	e1530008 	cmp	r3, r8                                        
   15250:	1a000002 	bne	15260 <_Timer_server_Body+0x128>              
   15254:	ea000015 	b	152b0 <_Timer_server_Body+0x178>                
   15258:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
   1525c:	eaffffcb 	b	15190 <_Timer_server_Body+0x58>                 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
   15260:	e10f2000 	mrs	r2, CPSR                                      
   15264:	e3823080 	orr	r3, r2, #128	; 0x80                           
   15268:	e129f003 	msr	CPSR_fc, r3                                   
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return (the_chain->first == _Chain_Tail(the_chain));                
   1526c:	e59d3008 	ldr	r3, [sp, #8]                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
   15270:	e1530008 	cmp	r3, r8                                        
   15274:	0a00000b 	beq	152a8 <_Timer_server_Body+0x170>              
{                                                                     
  Chain_Node  *return_node;                                           
  Chain_Node  *new_first;                                             
                                                                      
  return_node         = the_chain->first;                             
  new_first           = return_node->next;                            
   15278:	e5931000 	ldr	r1, [r3]                                      
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
   1527c:	e3530000 	cmp	r3, #0                                        
  the_chain->first    = new_first;                                    
   15280:	e58d1008 	str	r1, [sp, #8]                                  
  new_first->previous = _Chain_Head(the_chain);                       
   15284:	e5815004 	str	r5, [r1, #4]                                  
   15288:	0a000006 	beq	152a8 <_Timer_server_Body+0x170>              
          watchdog->state = WATCHDOG_INACTIVE;                        
   1528c:	e5839008 	str	r9, [r3, #8]                                  
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
   15290:	e129f002 	msr	CPSR_fc, r2                                   
        /*                                                            
         *  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 );    
   15294:	e2830020 	add	r0, r3, #32                                   
   15298:	e8900003 	ldm	r0, {r0, r1}                                  
   1529c:	e1a0e00f 	mov	lr, pc                                        
   152a0:	e593f01c 	ldr	pc, [r3, #28]                                 
      }                                                               
   152a4:	eaffffed 	b	15260 <_Timer_server_Body+0x128>                
   152a8:	e129f002 	msr	CPSR_fc, r2                                   
   152ac:	eaffffb5 	b	15188 <_Timer_server_Body+0x50>                 
    } else {                                                          
      ts->active = false;                                             
   152b0:	e5c4907c 	strb	r9, [r4, #124]	; 0x7c                        
   152b4:	e59f304c 	ldr	r3, [pc, #76]	; 15308 <_Timer_server_Body+0x1d0>
   152b8:	e5932000 	ldr	r2, [r3]                                      
   152bc:	e2822001 	add	r2, r2, #1                                    
   152c0:	e5832000 	str	r2, [r3]                                      
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
   152c4:	e3a01008 	mov	r1, #8                                        
   152c8:	e5940000 	ldr	r0, [r4]                                      
   152cc:	eb000d38 	bl	187b4 <_Thread_Set_state>                      
        _Timer_server_Reset_interval_system_watchdog( ts );           
   152d0:	e1a00004 	mov	r0, r4                                        
   152d4:	ebffff6b 	bl	15088 <_Timer_server_Reset_interval_system_watchdog>
        _Timer_server_Reset_tod_system_watchdog( ts );                
   152d8:	e1a00004 	mov	r0, r4                                        
   152dc:	ebffff7f 	bl	150e0 <_Timer_server_Reset_tod_system_watchdog>
      _Thread_Enable_dispatch();                                      
   152e0:	eb000aa4 	bl	17d78 <_Thread_Enable_dispatch>                
                                                                      
      ts->active = true;                                              
   152e4:	e3a03001 	mov	r3, #1                                        
   152e8:	e5c4307c 	strb	r3, [r4, #124]	; 0x7c                        
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
   152ec:	e59d0004 	ldr	r0, [sp, #4]                                  
   152f0:	eb001026 	bl	19390 <_Watchdog_Remove>                       
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
   152f4:	e59d0000 	ldr	r0, [sp]                                      
   152f8:	eb001024 	bl	19390 <_Watchdog_Remove>                       
   152fc:	eaffffa1 	b	15188 <_Timer_server_Body+0x50>                 
                                                                      

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

00018f20 <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) FINI_SYMBOL();
   18f20:	e1a04000 	mov	r4, r0                                        
   18f24:	eb000229 	bl	197d0 <___DTOR_END__>                          
   *  We need to do the exit processing on the global reentrancy structure.
   *  This has already been done on the per task reentrancy structure 
   *  associated with this task.                                      
   */                                                                 
                                                                      
  libc_wrapup();                                                      
   18f28:	ebffffe0 	bl	18eb0 <libc_wrapup>                            
  rtems_shutdown_executive(status);                                   
   18f2c:	e1a00004 	mov	r0, r4                                        
   18f30:	eb00003b 	bl	19024 <rtems_shutdown_executive>               
   18f34:	eafffffe 	b	18f34 <_exit+0x14>                              <== NOT EXECUTED
                                                                      

00022ca8 <_fat_block_read>: uint32_t start, uint32_t offset, uint32_t count, void *buff ) {
   22ca8:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
    int                     rc = RC_OK;                               
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
    ssize_t                 cmpltd = 0;                               
    uint32_t                blk = start;                              
    uint32_t                ofs = offset;                             
    rtems_bdbuf_buffer     *block = NULL;                             
   22cac:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   22cb0:	e28d7004 	add	r7, sp, #4                                    <== NOT EXECUTED
    uint32_t                              start,                      
    uint32_t                              offset,                     
    uint32_t                              count,                      
    void                                 *buff                        
    )                                                                 
{                                                                     
   22cb4:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
    int                     rc = RC_OK;                               
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   22cb8:	e5909034 	ldr	r9, [r0, #52]	; 0x34                          <== NOT EXECUTED
    ssize_t                 cmpltd = 0;                               
    uint32_t                blk = start;                              
    uint32_t                ofs = offset;                             
    rtems_bdbuf_buffer     *block = NULL;                             
   22cbc:	e5274004 	str	r4, [r7, #-4]!                                <== NOT EXECUTED
   22cc0:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   22cc4:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
   22cc8:	ea000012 	b	22d18 <_fat_block_read+0x70>                    <== NOT EXECUTED
    {                                                                 
        rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);  
   22ccc:	ebfffec4 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
        memcpy((buff + cmpltd), (block->buffer + ofs), c);            
   22cd0:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);  
        if (rc != RC_OK)                                              
   22cd4:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
        memcpy((buff + cmpltd), (block->buffer + ofs), c);            
   22cd8:	e0830004 	add	r0, r3, r4                                    <== NOT EXECUTED
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);  
        if (rc != RC_OK)                                              
   22cdc:	13e04000 	mvnne	r4, #0                                      <== NOT EXECUTED
   22ce0:	1a000012 	bne	22d30 <_fat_block_read+0x88>                  <== NOT EXECUTED
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
   22ce4:	e1d9a0b0 	ldrh	sl, [r9]                                     <== NOT EXECUTED
        memcpy((buff + cmpltd), (block->buffer + ofs), c);            
   22ce8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    {                                                                 
        rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);  
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
   22cec:	e066a00a 	rsb	sl, r6, sl                                    <== NOT EXECUTED
        memcpy((buff + cmpltd), (block->buffer + ofs), c);            
   22cf0:	e5931020 	ldr	r1, [r3, #32]                                 <== NOT EXECUTED
    {                                                                 
        rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);  
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
   22cf4:	e15a0005 	cmp	sl, r5                                        <== NOT EXECUTED
   22cf8:	21a0a005 	movcs	sl, r5                                      <== NOT EXECUTED
        memcpy((buff + cmpltd), (block->buffer + ofs), c);            
   22cfc:	e0811006 	add	r1, r1, r6                                    <== NOT EXECUTED
   22d00:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   22d04:	eb00752d 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
   22d08:	e08a4004 	add	r4, sl, r4                                    <== NOT EXECUTED
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
        memcpy((buff + cmpltd), (block->buffer + ofs), c);            
                                                                      
        count -= c;                                                   
   22d0c:	e06a5005 	rsb	r5, sl, r5                                    <== NOT EXECUTED
        cmpltd += c;                                                  
        blk++;                                                        
   22d10:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   22d14:	e1a0600b 	mov	r6, fp                                        <== NOT EXECUTED
    uint32_t                blk = start;                              
    uint32_t                ofs = offset;                             
    rtems_bdbuf_buffer     *block = NULL;                             
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
   22d18:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    {                                                                 
        rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);  
   22d1c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   22d20:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   22d24:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   22d28:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
    uint32_t                blk = start;                              
    uint32_t                ofs = offset;                             
    rtems_bdbuf_buffer     *block = NULL;                             
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
   22d2c:	1affffe6 	bne	22ccc <_fat_block_read+0x24>                  <== NOT EXECUTED
        cmpltd += c;                                                  
        blk++;                                                        
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
   22d30:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22d34:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

000227dc <_fat_block_release>: int _fat_block_release( rtems_filesystem_mount_table_entry_t *mt_entry) { fat_fs_info_t *fs_info = mt_entry->fs_info; return fat_buf_release(fs_info);
   227dc:	e5900034 	ldr	r0, [r0, #52]	; 0x34                          <== NOT EXECUTED
   227e0:	eaffffaf 	b	226a4 <fat_buf_release>                         <== NOT EXECUTED
                                                                      

000229bc <_fat_block_write>: rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t start, uint32_t offset, uint32_t count, const void *buff) {
   229bc:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
    int                 rc = RC_OK;                                   
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
    ssize_t             cmpltd = 0;                                   
    uint32_t            blk  = start;                                 
    uint32_t            ofs = offset;                                 
    rtems_bdbuf_buffer *block = NULL;                                 
   229c0:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   229c4:	e28d8004 	add	r8, sp, #4                                    <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              start,                      
    uint32_t                              offset,                     
    uint32_t                              count,                      
    const void                           *buff)                       
{                                                                     
   229c8:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
    int                 rc = RC_OK;                                   
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
   229cc:	e5906034 	ldr	r6, [r0, #52]	; 0x34                          <== NOT EXECUTED
    ssize_t             cmpltd = 0;                                   
    uint32_t            blk  = start;                                 
    uint32_t            ofs = offset;                                 
    rtems_bdbuf_buffer *block = NULL;                                 
   229d0:	e5285004 	str	r5, [r8, #-4]!                                <== NOT EXECUTED
   229d4:	e1a0b002 	mov	fp, r2                                        <== NOT EXECUTED
   229d8:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
    uint32_t            c = 0;                                        
                                                                      
    while(count > 0)                                                  
   229dc:	ea00001e 	b	22a5c <_fat_block_write+0xa0>                   <== NOT EXECUTED
    {                                                                 
        c = MIN(count, (fs_info->vol.bps - ofs));                     
   229e0:	e1d630b0 	ldrh	r3, [r6]                                     <== NOT EXECUTED
   229e4:	e06b4003 	rsb	r4, fp, r3                                    <== NOT EXECUTED
   229e8:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
   229ec:	21a04007 	movcs	r4, r7                                      <== NOT EXECUTED
                                                                      
        if (c == fs_info->vol.bps)                                    
   229f0:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
            rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
   229f4:	01a00006 	moveq	r0, r6                                      <== NOT EXECUTED
   229f8:	01a0100a 	moveq	r1, sl                                      <== NOT EXECUTED
   229fc:	03a02002 	moveq	r2, #2                                      <== NOT EXECUTED
   22a00:	01a0300d 	moveq	r3, sp                                      <== NOT EXECUTED
        else                                                          
            rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
   22a04:	11a0100a 	movne	r1, sl                                      <== NOT EXECUTED
   22a08:	13a02001 	movne	r2, #1                                      <== NOT EXECUTED
   22a0c:	11a0300d 	movne	r3, sp                                      <== NOT EXECUTED
   22a10:	11a00006 	movne	r0, r6                                      <== NOT EXECUTED
   22a14:	ebffff72 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
        if (rc != RC_OK)                                              
   22a18:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        c = MIN(count, (fs_info->vol.bps - ofs));                     
                                                                      
        if (c == fs_info->vol.bps)                                    
            rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
        else                                                          
            rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
   22a1c:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
        if (rc != RC_OK)                                              
   22a20:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
   22a24:	1a00000e 	bne	22a64 <_fat_block_write+0xa8>                 <== NOT EXECUTED
            return -1;                                                
                                                                      
        memcpy((block->buffer + ofs), (buff + cmpltd), c);            
   22a28:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   22a2c:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   22a30:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
   22a34:	e080000b 	add	r0, r0, fp                                    <== NOT EXECUTED
   22a38:	e0831005 	add	r1, r3, r5                                    <== NOT EXECUTED
   22a3c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   22a40:	eb0075de 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
   22a44:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   22a48:	e5c63080 	strb	r3, [r6, #128]	; 0x80                        <== NOT EXECUTED
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
        cmpltd +=c;                                                   
   22a4c:	e0845005 	add	r5, r4, r5                                    <== NOT EXECUTED
                                                                      
        memcpy((block->buffer + ofs), (buff + cmpltd), c);            
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
   22a50:	e0647007 	rsb	r7, r4, r7                                    <== NOT EXECUTED
        cmpltd +=c;                                                   
        blk++;                                                        
   22a54:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
   22a58:	e1a0b009 	mov	fp, r9                                        <== NOT EXECUTED
    uint32_t            blk  = start;                                 
    uint32_t            ofs = offset;                                 
    rtems_bdbuf_buffer *block = NULL;                                 
    uint32_t            c = 0;                                        
                                                                      
    while(count > 0)                                                  
   22a5c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   22a60:	1affffde 	bne	229e0 <_fat_block_write+0x24>                 <== NOT EXECUTED
        cmpltd +=c;                                                   
        blk++;                                                        
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
   22a64:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   22a68:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

00039da4 <_fcntl_r>: int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg );
   39da4:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   39da8:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
   39dac:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
   39db0:	eaffff8b 	b	39be4 <fcntl>                                   <== NOT EXECUTED
                                                                      

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

00001fcc <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp );
    1fcc:	eaffffe8 	b	1f74 <gettimeofday>                             <== NOT EXECUTED
                                                                      

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

00025f38 <_link_r>: struct _reent *ptr __attribute__((unused)), const char *existing, const char *new ) { return link( existing, new );
   25f38:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   25f3c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
   25f40:	eaffff7f 	b	25d44 <link>                                    <== NOT EXECUTED
                                                                      

00026134 <_lstat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
   26134:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   26138:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
   2613c:	eaffffc4 	b	26054 <lstat>                                   <== NOT EXECUTED
                                                                      

00019008 <_realloc_r>: struct _reent *ignored __attribute__((unused)), void *ptr, size_t size ) { return realloc( ptr, size );
   19008:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   1900c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
   19010:	ea00000e 	b	19050 <realloc>                                 <== NOT EXECUTED
                                                                      

00008f14 <_stat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
    8f14:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
    8f18:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
    8f1c:	eaffffc4 	b	8e34 <stat>                                     <== NOT EXECUTED
                                                                      

0000ced0 <_unlink_r>: int _unlink_r( struct _reent *ptr __attribute__((unused)), const char *path ) { return unlink( path );
    ced0:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
    ced4:	eaffff71 	b	cca0 <unlink>                                   <== NOT EXECUTED
                                                                      

00024dbc <chdir>: #include <rtems/seterr.h> int chdir( const char *pathname ) {
   24dbc:	e92d4030 	push	{r4, r5, lr}                                 
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if ( !pathname )                                                    
   24dc0:	e2505000 	subs	r5, r0, #0                                   
#include <rtems/seterr.h>                                             
                                                                      
int chdir(                                                            
  const char *pathname                                                
)                                                                     
{                                                                     
   24dc4:	e24dd018 	sub	sp, sp, #24                                   
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if ( !pathname )                                                    
   24dc8:	1a000002 	bne	24dd8 <chdir+0x1c>                            
    rtems_set_errno_and_return_minus_one( EFAULT );                   
   24dcc:	eb00604b 	bl	3cf00 <__errno>                                
   24dd0:	e3a0300e 	mov	r3, #14                                       
   24dd4:	ea000025 	b	24e70 <chdir+0xb4>                              
                                                                      
  /*                                                                  
   *  Get the node where we wish to go.                               
   */                                                                 
  result = rtems_filesystem_evaluate_path(                            
   24dd8:	eb007b45 	bl	43af4 <strlen>                                 
   24ddc:	e28d4004 	add	r4, sp, #4                                    
   24de0:	e3a0c001 	mov	ip, #1                                        
   24de4:	e1a01000 	mov	r1, r0                                        
   24de8:	e1a0200c 	mov	r2, ip                                        
   24dec:	e1a00005 	mov	r0, r5                                        
   24df0:	e1a03004 	mov	r3, r4                                        
   24df4:	e58dc000 	str	ip, [sp]                                      
   24df8:	ebff8a0f 	bl	763c <rtems_filesystem_evaluate_path>          
    pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
  if ( result != 0 )                                                  
   24dfc:	e3500000 	cmp	r0, #0                                        
   24e00:	1a00001b 	bne	24e74 <chdir+0xb8>                            
     return -1;                                                       
                                                                      
  /*                                                                  
   * Verify you can change directory into this node.                  
   */                                                                 
  if ( !loc.ops->node_type_h ) {                                      
   24e04:	e59d2010 	ldr	r2, [sp, #16]                                 
   24e08:	e5923010 	ldr	r3, [r2, #16]                                 
   24e0c:	e3530000 	cmp	r3, #0                                        
   24e10:	1a000007 	bne	24e34 <chdir+0x78>                            
    rtems_filesystem_freenode( &loc );                                
   24e14:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
   24e18:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   24e1c:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   24e20:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   24e24:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   24e28:	eb006034 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   24e2c:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   24e30:	ea00000e 	b	24e70 <chdir+0xb4>                              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
   24e34:	e1a00004 	mov	r0, r4                                        
   24e38:	e1a0e00f 	mov	lr, pc                                        
   24e3c:	e12fff13 	bx	r3                                             
   24e40:	e3500001 	cmp	r0, #1                                        
   24e44:	0a00000c 	beq	24e7c <chdir+0xc0>                            
    rtems_filesystem_freenode( &loc );                                
   24e48:	e59d3010 	ldr	r3, [sp, #16]                                 
   24e4c:	e3530000 	cmp	r3, #0                                        
   24e50:	0a000004 	beq	24e68 <chdir+0xac>                            
   24e54:	e593301c 	ldr	r3, [r3, #28]                                 
   24e58:	e3530000 	cmp	r3, #0                                        
   24e5c:	11a00004 	movne	r0, r4                                      
   24e60:	11a0e00f 	movne	lr, pc                                      
   24e64:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
   24e68:	eb006024 	bl	3cf00 <__errno>                                
   24e6c:	e3a03014 	mov	r3, #20                                       
   24e70:	e5803000 	str	r3, [r0]                                      
   24e74:	e3e00000 	mvn	r0, #0                                        
   24e78:	ea000012 	b	24ec8 <chdir+0x10c>                             
  }                                                                   
                                                                      
  rtems_filesystem_freenode( &rtems_filesystem_current );             
   24e7c:	e59f304c 	ldr	r3, [pc, #76]	; 24ed0 <chdir+0x114>           
   24e80:	e5930000 	ldr	r0, [r3]                                      
   24e84:	e5903010 	ldr	r3, [r0, #16]                                 
   24e88:	e3530000 	cmp	r3, #0                                        
   24e8c:	0a000004 	beq	24ea4 <chdir+0xe8>                            
   24e90:	e593301c 	ldr	r3, [r3, #28]                                 
   24e94:	e3530000 	cmp	r3, #0                                        
   24e98:	12800004 	addne	r0, r0, #4                                  
   24e9c:	11a0e00f 	movne	lr, pc                                      
   24ea0:	112fff13 	bxne	r3                                           
                                                                      
  rtems_filesystem_current = loc;                                     
   24ea4:	e59f3024 	ldr	r3, [pc, #36]	; 24ed0 <chdir+0x114>           
   24ea8:	e28d4004 	add	r4, sp, #4                                    
   24eac:	e593c000 	ldr	ip, [r3]                                      
   24eb0:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         
   24eb4:	e28cc004 	add	ip, ip, #4                                    
   24eb8:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
   24ebc:	e5943000 	ldr	r3, [r4]                                      
   24ec0:	e58c3000 	str	r3, [ip]                                      
   24ec4:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
   24ec8:	e28dd018 	add	sp, sp, #24                                   
   24ecc:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

00007140 <chmod>: int chmod( const char *path, mode_t mode ) {
    7140:	e92d4070 	push	{r4, r5, r6, lr}                             
    7144:	e24dd018 	sub	sp, sp, #24                                   
    7148:	e1a05001 	mov	r5, r1                                        
    714c:	e1a06000 	mov	r6, r0                                        
  int                              status;                            
  rtems_filesystem_location_info_t loc;                               
  int                              result;                            
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
    7150:	eb00f267 	bl	43af4 <strlen>                                 
    7154:	e28d4004 	add	r4, sp, #4                                    
    7158:	e1a01000 	mov	r1, r0                                        
    715c:	e3a0c001 	mov	ip, #1                                        
    7160:	e1a00006 	mov	r0, r6                                        
    7164:	e3a02000 	mov	r2, #0                                        
    7168:	e1a03004 	mov	r3, r4                                        
    716c:	e58dc000 	str	ip, [sp]                                      
    7170:	eb000131 	bl	763c <rtems_filesystem_evaluate_path>          
  if ( status != 0 )                                                  
    7174:	e3500000 	cmp	r0, #0                                        
    7178:	1a00000d 	bne	71b4 <chmod+0x74>                             
    return -1;                                                        
                                                                      
  if ( !loc.handlers ){                                               
    717c:	e59d300c 	ldr	r3, [sp, #12]                                 
    7180:	e3530000 	cmp	r3, #0                                        
    7184:	1a00000c 	bne	71bc <chmod+0x7c>                             
    rtems_filesystem_freenode( &loc );                                
    7188:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
    718c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    7190:	0a000004 	beq	71a8 <chmod+0x68>                             <== NOT EXECUTED
    7194:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    7198:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    719c:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    71a0:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    71a4:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EBADF );                    
    71a8:	eb00d754 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    71ac:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
    71b0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    71b4:	e3e05000 	mvn	r5, #0                                        
    71b8:	ea00001a 	b	7228 <chmod+0xe8>                               
  }                                                                   
                                                                      
  if ( !loc.handlers->fchmod_h ){                                     
    71bc:	e593301c 	ldr	r3, [r3, #28]                                 
    71c0:	e3530000 	cmp	r3, #0                                        
    71c4:	1a00000a 	bne	71f4 <chmod+0xb4>                             
    rtems_filesystem_freenode( &loc );                                
    71c8:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
    71cc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    71d0:	0a000004 	beq	71e8 <chmod+0xa8>                             <== NOT EXECUTED
    71d4:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    71d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    71dc:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    71e0:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    71e4:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    71e8:	eb00d744 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    71ec:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    71f0:	eaffffee 	b	71b0 <chmod+0x70>                               <== NOT EXECUTED
  }                                                                   
                                                                      
  result = (*loc.handlers->fchmod_h)( &loc, mode );                   
    71f4:	e1a01005 	mov	r1, r5                                        
    71f8:	e1a00004 	mov	r0, r4                                        
    71fc:	e1a0e00f 	mov	lr, pc                                        
    7200:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    7204:	e59d3010 	ldr	r3, [sp, #16]                                 
    7208:	e3530000 	cmp	r3, #0                                        
  if ( !loc.handlers->fchmod_h ){                                     
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*loc.handlers->fchmod_h)( &loc, mode );                   
    720c:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    7210:	0a000004 	beq	7228 <chmod+0xe8>                             
    7214:	e593301c 	ldr	r3, [r3, #28]                                 
    7218:	e3530000 	cmp	r3, #0                                        
    721c:	11a00004 	movne	r0, r4                                      
    7220:	11a0e00f 	movne	lr, pc                                      
    7224:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
    7228:	e1a00005 	mov	r0, r5                                        
    722c:	e28dd018 	add	sp, sp, #24                                   
    7230:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00024ed4 <chown>: int chown( const char *path, uid_t owner, gid_t group ) {
   24ed4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
   24ed8:	e1a01801 	lsl	r1, r1, #16                                   
   24edc:	e24dd018 	sub	sp, sp, #24                                   
   24ee0:	e1a02802 	lsl	r2, r2, #16                                   
   24ee4:	e1a06821 	lsr	r6, r1, #16                                   
   24ee8:	e1a05822 	lsr	r5, r2, #16                                   
   24eec:	e1a07000 	mov	r7, r0                                        
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, true ) )
   24ef0:	eb007aff 	bl	43af4 <strlen>                                 
   24ef4:	e28d4004 	add	r4, sp, #4                                    
   24ef8:	e1a01000 	mov	r1, r0                                        
   24efc:	e3a0c001 	mov	ip, #1                                        
   24f00:	e1a00007 	mov	r0, r7                                        
   24f04:	e3a02000 	mov	r2, #0                                        
   24f08:	e1a03004 	mov	r3, r4                                        
   24f0c:	e58dc000 	str	ip, [sp]                                      
   24f10:	ebff89c9 	bl	763c <rtems_filesystem_evaluate_path>          
   24f14:	e3500000 	cmp	r0, #0                                        
   24f18:	1a00000b 	bne	24f4c <chown+0x78>                            
    return -1;                                                        
                                                                      
  if ( !loc.ops->chown_h ) {                                          
   24f1c:	e59d2010 	ldr	r2, [sp, #16]                                 
   24f20:	e5923018 	ldr	r3, [r2, #24]                                 
   24f24:	e3530000 	cmp	r3, #0                                        
   24f28:	1a000009 	bne	24f54 <chown+0x80>                            
    rtems_filesystem_freenode( &loc );                                
   24f2c:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
   24f30:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   24f34:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   24f38:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   24f3c:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   24f40:	eb005fee 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   24f44:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   24f48:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   24f4c:	e3e05000 	mvn	r5, #0                                        
   24f50:	ea00000d 	b	24f8c <chown+0xb8>                              
  }                                                                   
                                                                      
  result = (*loc.ops->chown_h)( &loc, owner, group );                 
   24f54:	e1a02005 	mov	r2, r5                                        
   24f58:	e1a01006 	mov	r1, r6                                        
   24f5c:	e1a00004 	mov	r0, r4                                        
   24f60:	e1a0e00f 	mov	lr, pc                                        
   24f64:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   24f68:	e59d3010 	ldr	r3, [sp, #16]                                 
   24f6c:	e3530000 	cmp	r3, #0                                        
  if ( !loc.ops->chown_h ) {                                          
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*loc.ops->chown_h)( &loc, owner, group );                 
   24f70:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   24f74:	0a000004 	beq	24f8c <chown+0xb8>                            
   24f78:	e593301c 	ldr	r3, [r3, #28]                                 
   24f7c:	e3530000 	cmp	r3, #0                                        
   24f80:	11a00004 	movne	r0, r4                                      
   24f84:	11a0e00f 	movne	lr, pc                                      
   24f88:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
   24f8c:	e1a00005 	mov	r0, r5                                        
   24f90:	e28dd018 	add	sp, sp, #24                                   
   24f94:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

00024f98 <chroot>: #include <rtems/seterr.h> int chroot( const char *pathname ) {
   24f98:	e92d4070 	push	{r4, r5, r6, lr}                             
  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) {             
   24f9c:	e59f50d4 	ldr	r5, [pc, #212]	; 25078 <chroot+0xe0>          
   24fa0:	e59f30d4 	ldr	r3, [pc, #212]	; 2507c <chroot+0xe4>          
   24fa4:	e5954000 	ldr	r4, [r5]                                      
   24fa8:	e1540003 	cmp	r4, r3                                        
#include <rtems/seterr.h>                                             
                                                                      
int chroot(                                                           
  const char *pathname                                                
)                                                                     
{                                                                     
   24fac:	e24dd018 	sub	sp, sp, #24                                   
   24fb0:	e1a06000 	mov	r6, r0                                        
  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) {             
   24fb4:	1a000007 	bne	24fd8 <chroot+0x40>                           
   rtems_libio_set_private_env(); /* try to set a new private env*/   
   24fb8:	eb00058c 	bl	265f0 <rtems_libio_set_private_env>            
   if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 
   24fbc:	e5953000 	ldr	r3, [r5]                                      
   24fc0:	e1530004 	cmp	r3, r4                                        
   24fc4:	1a000003 	bne	24fd8 <chroot+0x40>                           
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   24fc8:	eb005fcc 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   24fcc:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   24fd0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   24fd4:	ea000008 	b	24ffc <chroot+0x64>                             <== NOT EXECUTED
  }                                                                   
                                                                      
  result = chdir(pathname);                                           
   24fd8:	e1a00006 	mov	r0, r6                                        
   24fdc:	ebffff76 	bl	24dbc <chdir>                                  
  if (result) {                                                       
   24fe0:	e250c000 	subs	ip, r0, #0                                   
   24fe4:	0a000006 	beq	25004 <chroot+0x6c>                           
    rtems_set_errno_and_return_minus_one( errno );                    
   24fe8:	eb005fc4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   24fec:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   24ff0:	eb005fc2 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   24ff4:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
   24ff8:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
   24ffc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   25000:	ea00001a 	b	25070 <chroot+0xd8>                             <== NOT EXECUTED
  }                                                                   
                                                                      
  /* clone the new root location */                                   
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
   25004:	e1a0200c 	mov	r2, ip                                        
   25008:	e59f0070 	ldr	r0, [pc, #112]	; 25080 <chroot+0xe8>          
   2500c:	e3a01001 	mov	r1, #1                                        
   25010:	e28d3004 	add	r3, sp, #4                                    
   25014:	e58dc000 	str	ip, [sp]                                      
   25018:	ebff8987 	bl	763c <rtems_filesystem_evaluate_path>          
   2501c:	e3500000 	cmp	r0, #0                                        
   25020:	1afffff0 	bne	24fe8 <chroot+0x50>                           
    /* 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);                  
   25024:	e59f304c 	ldr	r3, [pc, #76]	; 25078 <chroot+0xe0>           
   25028:	e5930000 	ldr	r0, [r3]                                      
   2502c:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          
   25030:	e3530000 	cmp	r3, #0                                        
   25034:	0a000004 	beq	2504c <chroot+0xb4>                           
   25038:	e593301c 	ldr	r3, [r3, #28]                                 
   2503c:	e3530000 	cmp	r3, #0                                        
   25040:	12800018 	addne	r0, r0, #24                                 
   25044:	11a0e00f 	movne	lr, pc                                      
   25048:	112fff13 	bxne	r3                                           
  rtems_filesystem_root = loc;                                        
   2504c:	e59f3024 	ldr	r3, [pc, #36]	; 25078 <chroot+0xe0>           
   25050:	e28d4004 	add	r4, sp, #4                                    
   25054:	e593c000 	ldr	ip, [r3]                                      
   25058:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         
   2505c:	e28cc018 	add	ip, ip, #24                                   
   25060:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
   25064:	e5943000 	ldr	r3, [r4]                                      
   25068:	e58c3000 	str	r3, [ip]                                      
   2506c:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
   25070:	e28dd018 	add	sp, sp, #24                                   
   25074:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

000020c0 <create_disk>: rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_filesystem_split_dev_t(dev, major, minor); if (major >= disktab_size) {
    20c0:	e59fc19c 	ldr	ip, [pc, #412]	; 2264 <create_disk+0x1a4>     
  return disktab [major].minor + minor;                               
}                                                                     
                                                                      
static rtems_status_code                                              
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)  
{                                                                     
    20c4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  rtems_filesystem_split_dev_t(dev, major, minor);                    
                                                                      
  if (major >= disktab_size) {                                        
    20c8:	e59c4000 	ldr	r4, [ip]                                      
    20cc:	e1500004 	cmp	r0, r4                                        
  return disktab [major].minor + minor;                               
}                                                                     
                                                                      
static rtems_status_code                                              
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)  
{                                                                     
    20d0:	e1a05000 	mov	r5, r0                                        
    20d4:	e1a06001 	mov	r6, r1                                        
    20d8:	e1a08002 	mov	r8, r2                                        
    20dc:	e1a09003 	mov	r9, r3                                        
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  rtems_filesystem_split_dev_t(dev, major, minor);                    
                                                                      
  if (major >= disktab_size) {                                        
    20e0:	3a00000e 	bcc	2120 <create_disk+0x60>                       
    rtems_disk_device_table *table = disktab;                         
    rtems_device_major_number old_size = disktab_size;                
    rtems_device_major_number new_size = 2 * old_size;                
    20e4:	e1a07084 	lsl	r7, r4, #1                                    
                                                                      
    if (major >= new_size) {                                          
    20e8:	e1500007 	cmp	r0, r7                                        
      new_size = major + 1;                                           
    20ec:	22857001 	addcs	r7, r5, #1                                  
  rtems_device_minor_number minor = 0;                                
                                                                      
  rtems_filesystem_split_dev_t(dev, major, minor);                    
                                                                      
  if (major >= disktab_size) {                                        
    rtems_disk_device_table *table = disktab;                         
    20f0:	e59c0004 	ldr	r0, [ip, #4]                                  
                                                                      
    if (major >= new_size) {                                          
      new_size = major + 1;                                           
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
    20f4:	e1a01187 	lsl	r1, r7, #3                                    
    20f8:	eb0006cd 	bl	3c34 <realloc>                                 
    if (table == NULL) {                                              
    20fc:	e250a000 	subs	sl, r0, #0                                   
    2100:	0a00004e 	beq	2240 <create_disk+0x180>                      
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
    2104:	e0642007 	rsb	r2, r4, r7                                    <== NOT EXECUTED
    2108:	e08a0184 	add	r0, sl, r4, lsl #3                            <== NOT EXECUTED
    210c:	e1a02182 	lsl	r2, r2, #3                                    <== NOT EXECUTED
    2110:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    2114:	eb003dd7 	bl	11878 <memset>                                 <== NOT EXECUTED
    disktab = table;                                                  
    2118:	e59f3144 	ldr	r3, [pc, #324]	; 2264 <create_disk+0x1a4>     <== NOT EXECUTED
    disktab_size = new_size;                                          
    211c:	e8830480 	stm	r3, {r7, sl}                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  if (disktab [major].minor == NULL || minor >= disktab[major].size) {
    2120:	e59f313c 	ldr	r3, [pc, #316]	; 2264 <create_disk+0x1a4>     
    2124:	e5933004 	ldr	r3, [r3, #4]                                  
    2128:	e7930185 	ldr	r0, [r3, r5, lsl #3]                          
    212c:	e1a0a185 	lsl	sl, r5, #3                                    
    2130:	e3500000 	cmp	r0, #0                                        
    2134:	e083300a 	add	r3, r3, sl                                    
    2138:	0a000002 	beq	2148 <create_disk+0x88>                       
    213c:	e5932004 	ldr	r2, [r3, #4]                                  
    2140:	e1560002 	cmp	r6, r2                                        
    2144:	3a000013 	bcc	2198 <create_disk+0xd8>                       
    rtems_disk_device **table = disktab [major].minor;                
    rtems_device_minor_number old_size = disktab [major].size;        
    2148:	e593b004 	ldr	fp, [r3, #4]                                  
    rtems_device_minor_number new_size = 0;                           
                                                                      
    if (old_size == 0) {                                              
    214c:	e35b0000 	cmp	fp, #0                                        
    2150:	03a04008 	moveq	r4, #8                                      
      new_size = DISKTAB_INITIAL_SIZE;                                
    } else {                                                          
      new_size = 2 * old_size;                                        
    2154:	11a0408b 	lslne	r4, fp, #1                                  
    }                                                                 
    if (minor >= new_size) {                                          
    2158:	e1560004 	cmp	r6, r4                                        
      new_size = minor + 1;                                           
    215c:	22864001 	addcs	r4, r6, #1                                  
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
    2160:	e1a01104 	lsl	r1, r4, #2                                    
    2164:	eb0006b2 	bl	3c34 <realloc>                                 
    if (table == NULL) {                                              
    2168:	e2507000 	subs	r7, r0, #0                                   
    216c:	0a000033 	beq	2240 <create_disk+0x180>                      
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
    2170:	e06b2004 	rsb	r2, fp, r4                                    
    2174:	e087010b 	add	r0, r7, fp, lsl #2                            
    2178:	e1a02102 	lsl	r2, r2, #2                                    
    217c:	e3a01000 	mov	r1, #0                                        
    2180:	eb003dbc 	bl	11878 <memset>                                 
    disktab [major].minor = table;                                    
    2184:	e59f30d8 	ldr	r3, [pc, #216]	; 2264 <create_disk+0x1a4>     
    2188:	e5933004 	ldr	r3, [r3, #4]                                  
    218c:	e083a00a 	add	sl, r3, sl                                    
    2190:	e7837185 	str	r7, [r3, r5, lsl #3]                          
    disktab [major].size = new_size;                                  
    2194:	e58a4004 	str	r4, [sl, #4]                                  
  }                                                                   
                                                                      
  return disktab [major].minor + minor;                               
    2198:	e59f30c4 	ldr	r3, [pc, #196]	; 2264 <create_disk+0x1a4>     
    219c:	e5933004 	ldr	r3, [r3, #4]                                  
    21a0:	e7937185 	ldr	r7, [r3, r5, lsl #3]                          
    21a4:	e0873106 	add	r3, r7, r6, lsl #2                            
{                                                                     
  rtems_disk_device **dd_entry = create_disk_table_entry(dev);        
  rtems_disk_device *dd = NULL;                                       
  char *alloc_name = NULL;                                            
                                                                      
  if (dd_entry == NULL) {                                             
    21a8:	e3530000 	cmp	r3, #0                                        
    21ac:	0a000023 	beq	2240 <create_disk+0x180>                      
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (*dd_entry != NULL) {                                            
    21b0:	e7973106 	ldr	r3, [r7, r6, lsl #2]                          
    21b4:	e3530000 	cmp	r3, #0                                        
    21b8:	13a0000c 	movne	r0, #12                                     
    21bc:	18bd8ff0 	popne	{r4, r5, r6, r7, r8, r9, sl, fp, pc}        
    return RTEMS_RESOURCE_IN_USE;                                     
  }                                                                   
                                                                      
  dd = malloc(sizeof(*dd));                                           
    21c0:	e3a00034 	mov	r0, #52	; 0x34                                
    21c4:	eb0003c8 	bl	30ec <malloc>                                  
  if (dd == NULL) {                                                   
    21c8:	e2504000 	subs	r4, r0, #0                                   
    21cc:	0a00001b 	beq	2240 <create_disk+0x180>                      
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    21d0:	e3580000 	cmp	r8, #0                                        
    21d4:	0a00000f 	beq	2218 <create_disk+0x158>                      
    alloc_name = strdup(name);                                        
    21d8:	e1a00008 	mov	r0, r8                                        
    21dc:	eb003f20 	bl	11e64 <strdup>                                 
                                                                      
    if (alloc_name == NULL) {                                         
    21e0:	e3500000 	cmp	r0, #0                                        
  if (dd == NULL) {                                                   
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    alloc_name = strdup(name);                                        
    21e4:	e1a08000 	mov	r8, r0                                        
    21e8:	e1a0a000 	mov	sl, r0                                        
                                                                      
    if (alloc_name == NULL) {                                         
    21ec:	1a000015 	bne	2248 <create_disk+0x188>                      
      free(dd);                                                       
    21f0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    21f4:	eb0002f0 	bl	2dbc <free>                                    <== NOT EXECUTED
    21f8:	e3a0001a 	mov	r0, #26                                       <== NOT EXECUTED
                                                                      
      return RTEMS_NO_MEMORY;                                         
    21fc:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
      free(alloc_name);                                               
    2200:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    2204:	eb0002ec 	bl	2dbc <free>                                    <== NOT EXECUTED
      free(dd);                                                       
    2208:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    220c:	eb0002ea 	bl	2dbc <free>                                    <== NOT EXECUTED
    2210:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
      return RTEMS_UNSATISFIED;                                       
    2214:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    2218:	e1a0a008 	mov	sl, r8                                        
    }                                                                 
  }                                                                   
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
  dd->uses = 0;                                                       
    221c:	e3a00000 	mov	r0, #0                                        
  dd->deleted = false;                                                
                                                                      
  *dd_entry = dd;                                                     
    2220:	e7874106 	str	r4, [r7, r6, lsl #2]                          
      free(dd);                                                       
      return RTEMS_UNSATISFIED;                                       
    }                                                                 
  }                                                                   
                                                                      
  dd->dev = dev;                                                      
    2224:	e5845000 	str	r5, [r4]                                      
  dd->name = alloc_name;                                              
  dd->uses = 0;                                                       
  dd->deleted = false;                                                
                                                                      
  *dd_entry = dd;                                                     
  *dd_ptr = dd;                                                       
    2228:	e5894000 	str	r4, [r9]                                      
      return RTEMS_UNSATISFIED;                                       
    }                                                                 
  }                                                                   
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
    222c:	e584a010 	str	sl, [r4, #16]                                 
      free(dd);                                                       
      return RTEMS_UNSATISFIED;                                       
    }                                                                 
  }                                                                   
                                                                      
  dd->dev = dev;                                                      
    2230:	e5846004 	str	r6, [r4, #4]                                  
  dd->name = alloc_name;                                              
  dd->uses = 0;                                                       
    2234:	e5840014 	str	r0, [r4, #20]                                 
  dd->deleted = false;                                                
    2238:	e5c40030 	strb	r0, [r4, #48]	; 0x30                         
                                                                      
  *dd_entry = dd;                                                     
  *dd_ptr = dd;                                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
    223c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
    2240:	e3a0001a 	mov	r0, #26                                       
}                                                                     
    2244:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
    2248:	e59f1018 	ldr	r1, [pc, #24]	; 2268 <create_disk+0x1a8>      
    224c:	e1a02005 	mov	r2, r5                                        
    2250:	e1a03006 	mov	r3, r6                                        
    2254:	eb0003e6 	bl	31f4 <mknod>                                   
    2258:	e3500000 	cmp	r0, #0                                        
    225c:	aaffffee 	bge	221c <create_disk+0x15c>                      
    2260:	eaffffe6 	b	2200 <create_disk+0x140>                        <== NOT EXECUTED
                                                                      

000080b0 <devFS_evaluate_path>: const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) {
    80b0:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
  int                   i;                                            
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* see if 'flags' is valid */                                       
  if ( !rtems_libio_is_valid_perms( flags ) )                         
    80b4:	e3d27007 	bics	r7, r2, #7                                   
  const char                        *pathname,                        
  size_t                             pathnamelen,                     
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc                          
)                                                                     
{                                                                     
    80b8:	e1a09000 	mov	r9, r0                                        
    80bc:	e1a04001 	mov	r4, r1                                        
    80c0:	e1a05003 	mov	r5, r3                                        
  int                   i;                                            
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* see if 'flags' is valid */                                       
  if ( !rtems_libio_is_valid_perms( flags ) )                         
    80c4:	0a000002 	beq	80d4 <devFS_evaluate_path+0x24>               
    rtems_set_errno_and_return_minus_one( EPERM );                    
    80c8:	eb00063b 	bl	99bc <__errno>                                 <== NOT EXECUTED
    80cc:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    80d0:	ea000005 	b	80ec <devFS_evaluate_path+0x3c>                 <== NOT EXECUTED
                                                                      
  /* get the device name table */                                     
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
    80d4:	e5936000 	ldr	r6, [r3]                                      
  if (!device_name_table)                                             
    80d8:	e3560000 	cmp	r6, #0                                        
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
    80dc:	159fa090 	ldrne	sl, [pc, #144]	; 8174 <devFS_evaluate_path+0xc4>
  if ( !rtems_libio_is_valid_perms( flags ) )                         
    rtems_set_errno_and_return_minus_one( EPERM );                    
                                                                      
  /* get the device name table */                                     
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    80e0:	1a000019 	bne	814c <devFS_evaluate_path+0x9c>               
    rtems_set_errno_and_return_minus_one( EFAULT );                   
    80e4:	eb000634 	bl	99bc <__errno>                                 <== NOT EXECUTED
    80e8:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
    80ec:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    80f0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    80f4:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
    if (!device_name_table[i].device_name)                            
    80f8:	e5968000 	ldr	r8, [r6]                                      
    80fc:	e2581000 	subs	r1, r8, #0                                   
    8100:	0a00000f 	beq	8144 <devFS_evaluate_path+0x94>               
      continue;                                                       
                                                                      
    if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
    8104:	eb0009e2 	bl	a894 <strncmp>                                 
    8108:	e3500000 	cmp	r0, #0                                        
    810c:	1a00000c 	bne	8144 <devFS_evaluate_path+0x94>               
      continue;                                                       
                                                                      
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
    8110:	e7d80004 	ldrb	r0, [r8, r4]                                 
    8114:	e3500000 	cmp	r0, #0                                        
    8118:	1a000009 	bne	8144 <devFS_evaluate_path+0x94>               
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
    pathloc->handlers = &devFS_file_handlers;                         
    pathloc->ops = &devFS_ops;                                        
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
    811c:	e59f3054 	ldr	r3, [pc, #84]	; 8178 <devFS_evaluate_path+0xc8>
    8120:	e5933000 	ldr	r3, [r3]                                      
    8124:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          
    8128:	e5853010 	str	r3, [r5, #16]                                 
    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;                         
    812c:	e59f3048 	ldr	r3, [pc, #72]	; 817c <devFS_evaluate_path+0xcc>
    8130:	e5853008 	str	r3, [r5, #8]                                  
    pathloc->ops = &devFS_ops;                                        
    8134:	e59f3044 	ldr	r3, [pc, #68]	; 8180 <devFS_evaluate_path+0xd0>
                                                                      
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
      continue;                                                       
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
    8138:	e5856000 	str	r6, [r5]                                      
    pathloc->handlers = &devFS_file_handlers;                         
    pathloc->ops = &devFS_ops;                                        
    813c:	e585300c 	str	r3, [r5, #12]                                 
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
    return 0;                                                         
    8140:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
  /* 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++) {                     
    8144:	e2877001 	add	r7, r7, #1                                    
    8148:	e2866014 	add	r6, r6, #20                                   
    814c:	e59a3000 	ldr	r3, [sl]                                      
    8150:	e1570003 	cmp	r7, r3                                        
    if (!device_name_table[i].device_name)                            
      continue;                                                       
                                                                      
    if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
    8154:	e1a00009 	mov	r0, r9                                        
    8158:	e1a02004 	mov	r2, r4                                        
  /* 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++) {                     
    815c:	3affffe5 	bcc	80f8 <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 );                     
    8160:	eb000615 	bl	99bc <__errno>                                 
    8164:	e3a03002 	mov	r3, #2                                        
    8168:	e5803000 	str	r3, [r0]                                      
    816c:	e3e00000 	mvn	r0, #0                                        
}                                                                     
    8170:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
                                                                      

000012a4 <devFS_initialize>: int devFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry, const void *data ) {
    12a4:	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(     
    12a8:	e59f7058 	ldr	r7, [pc, #88]	; 1308 <devFS_initialize+0x64>  
    12ac:	e5973000 	ldr	r3, [r7]                                      
    12b0:	e3a06014 	mov	r6, #20                                       
                                                                      
int devFS_initialize(                                                 
  rtems_filesystem_mount_table_entry_t *temp_mt_entry,                
  const void                           *data                          
)                                                                     
{                                                                     
    12b4:	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(     
    12b8:	e0000396 	mul	r0, r6, r3                                    
    12bc:	eb001a4f 	bl	7c00 <_Workspace_Allocate>                     
        sizeof( rtems_device_name_t ) * ( rtems_device_table_size )   
        );                                                            
                                                                      
  /* no memory for device filesystem */                               
  if (!device_name_table)                                             
    12c0:	e2505000 	subs	r5, r0, #0                                   
    12c4:	1a000004 	bne	12dc <devFS_initialize+0x38>                  
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
    12c8:	eb0021bb 	bl	99bc <__errno>                                 <== NOT EXECUTED
    12cc:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    12d0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    12d4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    12d8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  memset(                                                             
    12dc:	e5972000 	ldr	r2, [r7]                                      
    12e0:	e3a01000 	mov	r1, #0                                        
    12e4:	e0020296 	mul	r2, r6, r2                                    
    12e8:	eb0023e1 	bl	a274 <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;      
    12ec:	e59f3018 	ldr	r3, [pc, #24]	; 130c <devFS_initialize+0x68>  
  temp_mt_entry->mt_fs_root.ops          = &devFS_ops;                
    12f0:	e2832038 	add	r2, r3, #56	; 0x38                            
                                                                      
  /* Set the node_access to device name table */                      
  temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;  
    12f4:	e584501c 	str	r5, [r4, #28]                                 
    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;                
    12f8:	e5842028 	str	r2, [r4, #40]	; 0x28                          
    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;      
    12fc:	e5843024 	str	r3, [r4, #36]	; 0x24                          
  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;  
    1300:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
    1304:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

00001310 <devFS_mknod>: const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) {
    1310:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     
    1314:	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') &&                         
    1318:	e5d00000 	ldrb	r0, [r0]                                     
    131c:	e3500064 	cmp	r0, #100	; 0x64                               
  const char                        *path,                            
  mode_t                             mode,                            
  dev_t                              dev,                             
  rtems_filesystem_location_info_t  *pathloc                          
)                                                                     
{                                                                     
    1320:	e1a05001 	mov	r5, r1                                        
    1324:	e58d2000 	str	r2, [sp]                                      
    1328:	e1a09003 	mov	r9, 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') &&                         
    132c:	1a000008 	bne	1354 <devFS_mknod+0x44>                       
    1330:	e5d43001 	ldrb	r3, [r4, #1]                                 
    1334:	e3530065 	cmp	r3, #101	; 0x65                               
    1338:	1a000005 	bne	1354 <devFS_mknod+0x44>                       
      (path[2] == 'v') && (path[3] == '\0'))                          
    133c:	e5d43002 	ldrb	r3, [r4, #2]                                 
    1340:	e3530076 	cmp	r3, #118	; 0x76                               
    1344:	1a000002 	bne	1354 <devFS_mknod+0x44>                       
    1348:	e5d40003 	ldrb	r0, [r4, #3]                                 
    134c:	e3500000 	cmp	r0, #0                                        
    1350:	0a000039 	beq	143c <devFS_mknod+0x12c>                      
      return 0;                                                       
                                                                      
  /* must be a character device or a block device */                  
  if (!S_ISBLK(mode) && !S_ISCHR(mode))                               
    1354:	e205aa0f 	and	sl, r5, #61440	; 0xf000                       
    1358:	e35a0a02 	cmp	sl, #8192	; 0x2000                            
    135c:	135a0a06 	cmpne	sl, #24576	; 0x6000                         
    1360:	03a0a000 	moveq	sl, #0                                      
    1364:	13a0a001 	movne	sl, #1                                      
    1368:	0a000002 	beq	1378 <devFS_mknod+0x68>                       
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    136c:	eb002192 	bl	99bc <__errno>                                 <== NOT EXECUTED
    1370:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    1374:	ea000008 	b	139c <devFS_mknod+0x8c>                         <== NOT EXECUTED
  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;    
    1378:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          
    137c:	e5936000 	ldr	r6, [r3]                                      
  if (!device_name_table)                                             
    1380:	e3560000 	cmp	r6, #0                                        
    1384:	13e07000 	mvnne	r7, #0                                      
    1388:	11a0800a 	movne	r8, sl                                      
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
    138c:	159fb0ac 	ldrne	fp, [pc, #172]	; 1440 <devFS_mknod+0x130>   
    1390:	1a000010 	bne	13d8 <devFS_mknod+0xc8>                       
    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 );                   
    1394:	eb002188 	bl	99bc <__errno>                                 <== NOT EXECUTED
    1398:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
    139c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    13a0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    13a4:	ea000024 	b	143c <devFS_mknod+0x12c>                        <== NOT EXECUTED
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
      if (device_name_table[i].device_name == NULL)                   
    13a8:	e796300a 	ldr	r3, [r6, sl]                                  
    13ac:	e2531000 	subs	r1, r3, #0                                   
    13b0:	0a000005 	beq	13cc <devFS_mknod+0xbc>                       
          slot = i;                                                   
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
    13b4:	eb002456 	bl	a514 <strcmp>                                  <== NOT EXECUTED
    13b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    13bc:	1a000003 	bne	13d0 <devFS_mknod+0xc0>                       <== NOT EXECUTED
              rtems_set_errno_and_return_minus_one( EEXIST );         
    13c0:	eb00217d 	bl	99bc <__errno>                                 <== NOT EXECUTED
    13c4:	e3a03011 	mov	r3, #17                                       <== NOT EXECUTED
    13c8:	eafffff3 	b	139c <devFS_mknod+0x8c>                         <== NOT EXECUTED
    13cc:	e1a07008 	mov	r7, r8                                        
  /* 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++){           
    13d0:	e2888001 	add	r8, r8, #1                                    
    13d4:	e28aa014 	add	sl, sl, #20                                   
    13d8:	e59b3000 	ldr	r3, [fp]                                      
    13dc:	e1580003 	cmp	r8, r3                                        
      if (device_name_table[i].device_name == NULL)                   
          slot = i;                                                   
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
    13e0:	e1a00004 	mov	r0, r4                                        
  /* 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++){           
    13e4:	3affffef 	bcc	13a8 <devFS_mknod+0x98>                       
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
              rtems_set_errno_and_return_minus_one( EEXIST );         
  }                                                                   
                                                                      
  if (slot == -1)                                                     
    13e8:	e3770001 	cmn	r7, #1                                        
    13ec:	1a000004 	bne	1404 <devFS_mknod+0xf4>                       
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
    13f0:	eb002171 	bl	99bc <__errno>                                 <== NOT EXECUTED
    13f4:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    13f8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    13fc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    1400:	ea00000d 	b	143c <devFS_mknod+0x12c>                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    1404:	e10f8000 	mrs	r8, CPSR                                      
    1408:	e3883080 	orr	r3, r8, #128	; 0x80                           
    140c:	e129f003 	msr	CPSR_fc, r3                                   
                                                                      
  _ISR_Disable(level);                                                
  device_name_table[slot].device_name  = (char *)path;                
    1410:	e3a02014 	mov	r2, #20                                       
    1414:	e0030792 	mul	r3, r2, r7                                    
  device_name_table[slot].device_name_length = strlen(path);          
    1418:	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;                
    141c:	e7864003 	str	r4, [r6, r3]                                  
    1420:	e0866003 	add	r6, r6, r3                                    
  device_name_table[slot].device_name_length = strlen(path);          
    1424:	eb002502 	bl	a834 <strlen>                                  
  device_name_table[slot].major = major;                              
    1428:	e59d3000 	ldr	r3, [sp]                                      
  device_name_table[slot].minor = minor;                              
  device_name_table[slot].mode  = mode;                               
    142c:	e5865010 	str	r5, [r6, #16]                                 
  if (slot == -1)                                                     
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
                                                                      
  _ISR_Disable(level);                                                
  device_name_table[slot].device_name  = (char *)path;                
  device_name_table[slot].device_name_length = strlen(path);          
    1430:	e9860209 	stmib	r6, {r0, r3, r9}                            
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    1434:	e129f008 	msr	CPSR_fc, r8                                   
    1438:	e3a00000 	mov	r0, #0                                        
  device_name_table[slot].minor = minor;                              
  device_name_table[slot].mode  = mode;                               
  _ISR_Enable(level);                                                 
                                                                      
  return 0;                                                           
}                                                                     
    143c:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      
                                                                      

000014c0 <devFS_read>: ssize_t devFS_read( rtems_libio_t *iop, void *buffer, size_t count ) {
    14c0:	e92d487f 	push	{r0, r1, r2, r3, r4, r5, r6, fp, lr}         <== NOT EXECUTED
    14c4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
    14c8:	e5900014 	ldr	r0, [r0, #20]                                 <== NOT EXECUTED
  np               = (rtems_device_name_t *)iop->file_info;           
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
    14cc:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
    14d0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    14d4:	e58d2018 	str	r2, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
    14d8:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
{                                                                     
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->file_info;           
    14dc:	e5932038 	ldr	r2, [r3, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
    14e0:	e283c00c 	add	ip, r3, #12                                   <== NOT EXECUTED
    14e4:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
  args.buffer      = buffer;                                          
    14e8:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
    14ec:	e2820008 	add	r0, r2, #8                                    <== NOT EXECUTED
    14f0:	e8900003 	ldm	r0, {r0, r1}                                  <== NOT EXECUTED
    14f4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->file_info;           
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
    14f8:	e98d1800 	stmib	sp, {fp, ip}                                <== NOT EXECUTED
  rtems_status_code       status;                                     
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->file_info;           
                                                                      
  args.iop         = iop;                                             
    14fc:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
    1500:	eb000f82 	bl	5310 <rtems_io_read>                           <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    1504:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
    1508:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
    150c:	1b001b1c 	blne	8184 <rtems_deviceio_errno>                  <== NOT EXECUTED
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
    1510:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
    1514:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
                                                                      

00001518 <devFS_stat>: struct stat *buf ) { rtems_device_name_t *the_dev; the_dev = (rtems_device_name_t *)loc->node_access;
    1518:	e5903000 	ldr	r3, [r0]                                      
  if (!the_dev)                                                       
    151c:	e3530000 	cmp	r3, #0                                        
                                                                      
int devFS_stat(                                                       
  rtems_filesystem_location_info_t *loc,                              
  struct stat                      *buf                               
)                                                                     
{                                                                     
    1520:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_device_name_t *the_dev;                                       
                                                                      
  the_dev = (rtems_device_name_t *)loc->node_access;                  
  if (!the_dev)                                                       
    1524:	1a000004 	bne	153c <devFS_stat+0x24>                        
    rtems_set_errno_and_return_minus_one( EFAULT );                   
    1528:	eb002123 	bl	99bc <__errno>                                 <== NOT EXECUTED
    152c:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
    1530:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1534:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    1538:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
                                                                      
  buf->st_mode = the_dev->mode;                                       
    153c:	e5930010 	ldr	r0, [r3, #16]                                 
                                                                      
  the_dev = (rtems_device_name_t *)loc->node_access;                  
  if (!the_dev)                                                       
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
    1540:	e593200c 	ldr	r2, [r3, #12]                                 
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
    1544:	e5933008 	ldr	r3, [r3, #8]                                  
    1548:	e581201c 	str	r2, [r1, #28]                                 
                                                                      
  buf->st_mode = the_dev->mode;                                       
    154c:	e581000c 	str	r0, [r1, #12]                                 
                                                                      
  the_dev = (rtems_device_name_t *)loc->node_access;                  
  if (!the_dev)                                                       
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
    1550:	e5813018 	str	r3, [r1, #24]                                 
                                                                      
  buf->st_mode = the_dev->mode;                                       
    1554:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
    1558:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

0000c7a4 <device_read>: ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) {
    c7a4:	e92d487f 	push	{r0, r1, r2, r3, r4, r5, r6, fp, lr}         
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
    c7a8:	e5903014 	ldr	r3, [r0, #20]                                 
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->file_info;                                         
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
    c7ac:	e280c00c 	add	ip, r0, #12                                   
    c7b0:	e89c1800 	ldm	ip, {fp, ip}                                  
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
    c7b4:	e58d3014 	str	r3, [sp, #20]                                 
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->file_info;                                         
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
    c7b8:	e98d1800 	stmib	sp, {fp, ip}                                
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
    c7bc:	e3a03000 	mov	r3, #0                                        
  the_jnode = iop->file_info;                                         
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
    c7c0:	e58d2010 	str	r2, [sp, #16]                                 
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
    c7c4:	e58d3018 	str	r3, [sp, #24]                                 
                                                                      
  the_jnode = iop->file_info;                                         
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
    c7c8:	e58d100c 	str	r1, [sp, #12]                                 
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->file_info;                                         
                                                                      
  args.iop         = iop;                                             
    c7cc:	e58d0000 	str	r0, [sp]                                      
{                                                                     
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->file_info;                                         
    c7d0:	e5903038 	ldr	r3, [r0, #56]	; 0x38                          
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
    c7d4:	e1a0200d 	mov	r2, sp                                        
    c7d8:	e2830050 	add	r0, r3, #80	; 0x50                            
    c7dc:	e8900003 	ldm	r0, {r0, r1}                                  
    c7e0:	eb00024e 	bl	d120 <rtems_io_read>                           
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    c7e4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
    c7e8:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
    c7ec:	1b0002c7 	blne	d310 <rtems_deviceio_errno>                  <== NOT EXECUTED
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
    c7f0:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
    c7f4:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
                                                                      

00001d80 <disk_unlock>: static void disk_unlock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; diskdevs_protected = false;
    1d80:	e59f3020 	ldr	r3, [pc, #32]	; 1da8 <disk_unlock+0x28>       
    1d84:	e3a02000 	mov	r2, #0                                        
  }                                                                   
}                                                                     
                                                                      
static void                                                           
disk_unlock(void)                                                     
{                                                                     
    1d88:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
    1d8c:	e5930008 	ldr	r0, [r3, #8]                                  
static void                                                           
disk_unlock(void)                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
    1d90:	e5c3200c 	strb	r2, [r3, #12]                                
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
    1d94:	eb0011c0 	bl	649c <rtems_semaphore_release>                 
  if (sc != RTEMS_SUCCESSFUL) {                                       
    1d98:	e3500000 	cmp	r0, #0                                        
    1d9c:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
    /* FIXME: Error number */                                         
    rtems_fatal_error_occurred(0xdeadbeef);                           
    1da0:	e59f0004 	ldr	r0, [pc, #4]	; 1dac <disk_unlock+0x2c>        <== NOT EXECUTED
    1da4:	eb0012e4 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

00003aa0 <drainOutput>: drainOutput (struct rtems_termios_tty *tty) { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
    3aa0:	e59030b4 	ldr	r3, [r0, #180]	; 0xb4                         
    3aa4:	e3530000 	cmp	r3, #0                                        
/*                                                                    
 * Drain output queue                                                 
 */                                                                   
static void                                                           
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
    3aa8:	e92d4030 	push	{r4, r5, lr}                                 
    3aac:	e1a04000 	mov	r4, r0                                        
	rtems_interrupt_level level;                                         
	rtems_status_code sc;                                                
                                                                      
	if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {            
    3ab0:	08bd8030 	popeq	{r4, r5, pc}                                
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    3ab4:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
    3ab8:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
    3abc:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
		rtems_interrupt_disable (level);                                    
		while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {                
			tty->rawOutBufState = rob_wait;                                    
    3ac0:	e3a05002 	mov	r5, #2                                        <== 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) {                
    3ac4:	ea00000a 	b	3af4 <drainOutput+0x54>                         <== NOT EXECUTED
			tty->rawOutBufState = rob_wait;                                    
    3ac8:	e5845094 	str	r5, [r4, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    3acc:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
			rtems_interrupt_enable (level);                                    
			sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,             
    3ad0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    3ad4:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         <== NOT EXECUTED
    3ad8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    3adc:	eb0005ae 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
							RTEMS_WAIT,                                                    
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
    3ae0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
    3ae4:	1b00072f 	blne	57a8 <rtems_fatal_error_occurred>            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    3ae8:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
    3aec:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
    3af0:	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) {                
    3af4:	e5941084 	ldr	r1, [r4, #132]	; 0x84                         <== NOT EXECUTED
    3af8:	e5942080 	ldr	r2, [r4, #128]	; 0x80                         <== NOT EXECUTED
    3afc:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    3b00:	1afffff0 	bne	3ac8 <drainOutput+0x28>                       <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    3b04:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    3b08:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00002568 <dup2>: int dup2( int fildes, int fildes2 ) {
    2568:	e92d4070 	push	{r4, r5, r6, lr}                             
    256c:	e24dd048 	sub	sp, sp, #72	; 0x48                            
    2570:	e1a04001 	mov	r4, r1                                        
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
    2574:	e1a0100d 	mov	r1, sp                                        
                                                                      
int dup2(                                                             
  int fildes,                                                         
  int fildes2                                                         
)                                                                     
{                                                                     
    2578:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
    257c:	eb000181 	bl	2b88 <fstat>                                   
  if ( status == -1 )                                                 
    2580:	e3700001 	cmn	r0, #1                                        
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
    2584:	e1a0500d 	mov	r5, sp                                        
  if ( status == -1 )                                                 
    2588:	0a000009 	beq	25b4 <dup2+0x4c>                              
                                                                      
  /*                                                                  
   *  If fildes2 is not valid, then we should not do anything either. 
   */                                                                 
                                                                      
  status = fstat( fildes2, &buf );                                    
    258c:	e1a0100d 	mov	r1, sp                                        
    2590:	e1a00004 	mov	r0, r4                                        
    2594:	eb00017b 	bl	2b88 <fstat>                                   
  if ( status == -1 )                                                 
    2598:	e3700001 	cmn	r0, #1                                        
    259c:	0a000004 	beq	25b4 <dup2+0x4c>                              
                                                                      
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
    25a0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    25a4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    25a8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    25ac:	eb00007b 	bl	27a0 <fcntl>                                   <== NOT EXECUTED
    25b0:	ea000000 	b	25b8 <dup2+0x50>                                <== NOT EXECUTED
    25b4:	e3e00000 	mvn	r0, #0                                        
}                                                                     
    25b8:	e28dd048 	add	sp, sp, #72	; 0x48                            
    25bc:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

000035a0 <echo>: * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
    35a0:	e591303c 	ldr	r3, [r1, #60]	; 0x3c                          <== NOT EXECUTED
    35a4:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
/*                                                                    
 * Echo a typed character                                             
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
    35a8:	e92d4011 	push	{r0, r4, lr}                                 <== NOT EXECUTED
    35ac:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    35b0:	e20000ff 	and	r0, r0, #255	; 0xff                           <== NOT EXECUTED
	if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
    35b4:	0a000015 	beq	3610 <echo+0x70>                              <== NOT EXECUTED
    35b8:	e59f305c 	ldr	r3, [pc, #92]	; 361c <echo+0x7c>              <== NOT EXECUTED
    35bc:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    35c0:	e0833000 	add	r3, r3, r0                                    <== NOT EXECUTED
    35c4:	e5d32001 	ldrb	r2, [r3, #1]                                 <== NOT EXECUTED
    35c8:	e2503009 	subs	r3, r0, #9                                   <== NOT EXECUTED
    35cc:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
    35d0:	e01332a2 	ands	r3, r3, r2, lsr #5                           <== NOT EXECUTED
    35d4:	0a00000d 	beq	3610 <echo+0x70>                              <== NOT EXECUTED
    35d8:	e350000a 	cmp	r0, #10                                       <== NOT EXECUTED
    35dc:	0a00000b 	beq	3610 <echo+0x70>                              <== NOT EXECUTED
		char echobuf[2];                                                    
                                                                      
		echobuf[0] = '^';                                                   
		echobuf[1] = c ^ 0x40;                                              
    35e0:	e2203040 	eor	r3, r0, #64	; 0x40                            <== NOT EXECUTED
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
	if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
		char echobuf[2];                                                    
                                                                      
		echobuf[0] = '^';                                                   
    35e4:	e3a0c05e 	mov	ip, #94	; 0x5e                                <== NOT EXECUTED
		echobuf[1] = c ^ 0x40;                                              
		rtems_termios_puts (echobuf, 2, tty);                               
    35e8:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
    35ec:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
    35f0:	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;                                              
    35f4:	e5cd3001 	strb	r3, [sp, #1]                                 <== NOT EXECUTED
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
	if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
		char echobuf[2];                                                    
                                                                      
		echobuf[0] = '^';                                                   
    35f8:	e5cdc000 	strb	ip, [sp]                                     <== NOT EXECUTED
		echobuf[1] = c ^ 0x40;                                              
		rtems_termios_puts (echobuf, 2, tty);                               
    35fc:	ebffff50 	bl	3344 <rtems_termios_puts>                      <== NOT EXECUTED
		tty->column += 2;                                                   
    3600:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    3604:	e2833002 	add	r3, r3, #2                                    <== NOT EXECUTED
    3608:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
 * Echo a typed character                                             
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
	if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
    360c:	ea000001 	b	3618 <echo+0x78>                                <== NOT EXECUTED
		echobuf[1] = c ^ 0x40;                                              
		rtems_termios_puts (echobuf, 2, tty);                               
		tty->column += 2;                                                   
	}                                                                    
	else {                                                               
		oproc (c, tty);                                                     
    3610:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    3614:	ebffff8b 	bl	3448 <oproc>                                   <== NOT EXECUTED
	}                                                                    
}                                                                     
    3618:	e8bd8018 	pop	{r3, r4, pc}                                  <== NOT EXECUTED
                                                                      

00025404 <endgrent>: group_fp = fopen("/etc/group", "r"); } void endgrent(void) { if (group_fp != NULL)
   25404:	e59f300c 	ldr	r3, [pc, #12]	; 25418 <endgrent+0x14>         <== NOT EXECUTED
   25408:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   2540c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   25410:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    fclose(group_fp);                                                 
   25414:	ea005f06 	b	3d034 <fclose>                                  <== NOT EXECUTED
                                                                      

0002541c <endpwent>: passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { if (passwd_fp != NULL)
   2541c:	e59f300c 	ldr	r3, [pc, #12]	; 25430 <endpwent+0x14>         <== NOT EXECUTED
   25420:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
   25424:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   25428:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    fclose(passwd_fp);                                                
   2542c:	ea005f00 	b	3d034 <fclose>                                  <== NOT EXECUTED
                                                                      

00003620 <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)
    3620:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
    3624:	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)                   
{                                                                     
    3628:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
    362c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    3630:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
	if (tty->ccount == 0)                                                
    3634:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
		return;                                                             
	if (lineFlag) {                                                      
    3638:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
    363c:	0a000062 	beq	37cc <erase+0x1ac>                            <== NOT EXECUTED
		if (!(tty->termios.c_lflag & ECHO)) {                               
    3640:	e590303c 	ldr	r3, [r0, #60]	; 0x3c                          <== NOT EXECUTED
    3644:	e2132008 	ands	r2, r3, #8                                   <== NOT EXECUTED
			tty->ccount = 0;                                                   
    3648:	05802020 	streq	r2, [r0, #32]                               <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
	if (tty->ccount == 0)                                                
		return;                                                             
	if (lineFlag) {                                                      
		if (!(tty->termios.c_lflag & ECHO)) {                               
    364c:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
			tty->ccount = 0;                                                   
			return;                                                            
		}                                                                   
		if (!(tty->termios.c_lflag & ECHOE)) {                              
    3650:	e2133010 	ands	r3, r3, #16                                  <== NOT EXECUTED
    3654:	1a00005c 	bne	37cc <erase+0x1ac>                            <== NOT EXECUTED
			tty->ccount = 0;                                                   
    3658:	e5803020 	str	r3, [r0, #32]                                 <== NOT EXECUTED
			echo (tty->termios.c_cc[VKILL], tty);                              
    365c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    3660:	e5d00044 	ldrb	r0, [r0, #68]	; 0x44                         <== NOT EXECUTED
    3664:	ebffffcd 	bl	35a0 <echo>                                    <== NOT EXECUTED
			if (tty->termios.c_lflag & ECHOK)                                  
    3668:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
    366c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
				echo ('\n', tty);                                                 
    3670:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
    3674:	13a0000a 	movne	r0, #10                                     <== NOT EXECUTED
			return;                                                            
		}                                                                   
		if (!(tty->termios.c_lflag & ECHOE)) {                              
			tty->ccount = 0;                                                   
			echo (tty->termios.c_cc[VKILL], tty);                              
			if (tty->termios.c_lflag & ECHOK)                                  
    3678:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
    367c:	ea00000c 	b	36b4 <erase+0x94>                               <== NOT EXECUTED
				echo ('\n', tty);                                                 
			return;                                                            
		}                                                                   
	}                                                                    
	while (tty->ccount) {                                                
		unsigned char c = tty->cbuf[--tty->ccount];                         
    3680:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
                                                                      
		if (tty->termios.c_lflag & ECHO) {                                  
    3684:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
				echo ('\n', tty);                                                 
			return;                                                            
		}                                                                   
	}                                                                    
	while (tty->ccount) {                                                
		unsigned char c = tty->cbuf[--tty->ccount];                         
    3688:	e5841020 	str	r1, [r4, #32]                                 <== NOT EXECUTED
    368c:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
                                                                      
		if (tty->termios.c_lflag & ECHO) {                                  
    3690:	e3130008 	tst	r3, #8                                        <== NOT EXECUTED
				echo ('\n', tty);                                                 
			return;                                                            
		}                                                                   
	}                                                                    
	while (tty->ccount) {                                                
		unsigned char c = tty->cbuf[--tty->ccount];                         
    3694:	e7d25001 	ldrb	r5, [r2, r1]                                 <== NOT EXECUTED
                                                                      
		if (tty->termios.c_lflag & ECHO) {                                  
    3698:	0a000048 	beq	37c0 <erase+0x1a0>                            <== NOT EXECUTED
			if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {                
    369c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    36a0:	1a000005 	bne	36bc <erase+0x9c>                             <== NOT EXECUTED
    36a4:	e3130010 	tst	r3, #16                                       <== NOT EXECUTED
    36a8:	1a000003 	bne	36bc <erase+0x9c>                             <== NOT EXECUTED
				echo (tty->termios.c_cc[VERASE], tty);                            
    36ac:	e5d40043 	ldrb	r0, [r4, #67]	; 0x43                         <== NOT EXECUTED
    36b0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
			}                                                                  
		}                                                                   
		if (!lineFlag)                                                      
			break;                                                             
	}                                                                    
}                                                                     
    36b4:	e8bd41f0 	pop	{r4, r5, r6, r7, r8, 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);                            
    36b8:	eaffffb8 	b	35a0 <echo>                                     <== NOT EXECUTED
			}                                                                  
			else if (c == '\t') {                                              
    36bc:	e3550009 	cmp	r5, #9                                        <== NOT EXECUTED
    36c0:	1a000020 	bne	3748 <erase+0x128>                            <== NOT EXECUTED
					c = tty->cbuf[i++];                                              
					if (c == '\t') {                                                 
						col = (col | 7) + 1;                                            
					}                                                                
					else if (iscntrl (c)) {                                          
						if (tty->termios.c_lflag & ECHOCTL)                             
    36c4:	e2033c02 	and	r3, r3, #512	; 0x200                          <== 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;                                 
    36c8:	e594502c 	ldr	r5, [r4, #44]	; 0x2c                          <== NOT EXECUTED
				while (i != tty->ccount) {                                        
					c = tty->cbuf[i++];                                              
					if (c == '\t') {                                                 
						col = (col | 7) + 1;                                            
					}                                                                
					else if (iscntrl (c)) {                                          
    36cc:	e596c000 	ldr	ip, [r6]                                      <== NOT EXECUTED
    36d0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
				int i = 0;                                                        
                                                                      
				/*                                                                
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
    36d4:	ea00000d 	b	3710 <erase+0xf0>                               <== NOT EXECUTED
					c = tty->cbuf[i++];                                              
    36d8:	e594001c 	ldr	r0, [r4, #28]                                 <== NOT EXECUTED
    36dc:	e7d00002 	ldrb	r0, [r0, r2]                                 <== NOT EXECUTED
					if (c == '\t') {                                                 
    36e0:	e3500009 	cmp	r0, #9                                        <== NOT EXECUTED
						col = (col | 7) + 1;                                            
					}                                                                
					else if (iscntrl (c)) {                                          
    36e4:	e08c8000 	add	r8, ip, r0                                    <== NOT EXECUTED
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
					c = tty->cbuf[i++];                                              
					if (c == '\t') {                                                 
						col = (col | 7) + 1;                                            
    36e8:	03855007 	orreq	r5, r5, #7                                  <== NOT EXECUTED
				/*                                                                
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
					c = tty->cbuf[i++];                                              
					if (c == '\t') {                                                 
    36ec:	0a000005 	beq	3708 <erase+0xe8>                             <== NOT EXECUTED
						col = (col | 7) + 1;                                            
					}                                                                
					else if (iscntrl (c)) {                                          
    36f0:	e5d80001 	ldrb	r0, [r8, #1]                                 <== NOT EXECUTED
    36f4:	e3100020 	tst	r0, #32                                       <== NOT EXECUTED
    36f8:	0a000002 	beq	3708 <erase+0xe8>                             <== NOT EXECUTED
						if (tty->termios.c_lflag & ECHOCTL)                             
    36fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
							col += 2;                                                      
    3700:	12855002 	addne	r5, r5, #2                                  <== NOT EXECUTED
    3704:	ea000000 	b	370c <erase+0xec>                               <== NOT EXECUTED
					}                                                                
					else {                                                           
						col++;                                                          
    3708:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
                                                                      
				/*                                                                
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
					c = tty->cbuf[i++];                                              
    370c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
				int i = 0;                                                        
                                                                      
				/*                                                                
				 * Find the character before the tab                              
				 */                                                               
				while (i != tty->ccount) {                                        
    3710:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
    3714:	1affffef 	bne	36d8 <erase+0xb8>                             <== NOT EXECUTED
    3718:	ea000006 	b	3738 <erase+0x118>                              <== NOT EXECUTED
                                                                      
				/*                                                                
				 * Back up over the tab                                           
				 */                                                               
				while (tty->column > col) {                                       
					rtems_termios_puts ("\b", 1, tty);                               
    371c:	e59f00bc 	ldr	r0, [pc, #188]	; 37e0 <erase+0x1c0>           <== NOT EXECUTED
    3720:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    3724:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    3728:	ebffff05 	bl	3344 <rtems_termios_puts>                      <== NOT EXECUTED
					tty->column--;                                                   
    372c:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    3730:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    3734:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
				}                                                                 
                                                                      
				/*                                                                
				 * Back up over the tab                                           
				 */                                                               
				while (tty->column > col) {                                       
    3738:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    373c:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
    3740:	cafffff5 	bgt	371c <erase+0xfc>                             <== NOT EXECUTED
    3744:	ea00001d 	b	37c0 <erase+0x1a0>                              <== NOT EXECUTED
					rtems_termios_puts ("\b", 1, tty);                               
					tty->column--;                                                   
				}                                                                 
			}                                                                  
			else {                                                             
				if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {            
    3748:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
    374c:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    3750:	e7d22005 	ldrb	r2, [r2, r5]                                 <== NOT EXECUTED
    3754:	e3120020 	tst	r2, #32                                       <== NOT EXECUTED
    3758:	0a000009 	beq	3784 <erase+0x164>                            <== NOT EXECUTED
    375c:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
    3760:	0a000007 	beq	3784 <erase+0x164>                            <== NOT EXECUTED
					rtems_termios_puts ("\b \b", 3, tty);                            
    3764:	e59f0078 	ldr	r0, [pc, #120]	; 37e4 <erase+0x1c4>           <== NOT EXECUTED
    3768:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
    376c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    3770:	ebfffef3 	bl	3344 <rtems_termios_puts>                      <== NOT EXECUTED
					if (tty->column)                                                 
    3774:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    3778:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
						tty->column--;                                                  
    377c:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
    3780:	15843028 	strne	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
				}                                                                 
				if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {           
    3784:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    3788:	e7d33005 	ldrb	r3, [r3, r5]                                 <== NOT EXECUTED
    378c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
    3790:	0a000002 	beq	37a0 <erase+0x180>                            <== NOT EXECUTED
    3794:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
    3798:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
    379c:	0a000007 	beq	37c0 <erase+0x1a0>                            <== NOT EXECUTED
					rtems_termios_puts ("\b \b", 3, tty);                            
    37a0:	e59f003c 	ldr	r0, [pc, #60]	; 37e4 <erase+0x1c4>            <== NOT EXECUTED
    37a4:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
    37a8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    37ac:	ebfffee4 	bl	3344 <rtems_termios_puts>                      <== NOT EXECUTED
					if (tty->column)                                                 
    37b0:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    37b4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
						tty->column--;                                                  
    37b8:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
    37bc:	15843028 	strne	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
				}                                                                 
			}                                                                  
		}                                                                   
		if (!lineFlag)                                                      
    37c0:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    37c4:	1a000001 	bne	37d0 <erase+0x1b0>                            <== NOT EXECUTED
    37c8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    37cc:	e59f6014 	ldr	r6, [pc, #20]	; 37e8 <erase+0x1c8>            <== NOT EXECUTED
			if (tty->termios.c_lflag & ECHOK)                                  
				echo ('\n', tty);                                                 
			return;                                                            
		}                                                                   
	}                                                                    
	while (tty->ccount) {                                                
    37d0:	e5941020 	ldr	r1, [r4, #32]                                 <== NOT EXECUTED
    37d4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
    37d8:	1affffa8 	bne	3680 <erase+0x60>                             <== NOT EXECUTED
    37dc:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

000227e4 <fat_buf_access>: #include "fat_fat_operations.h" int fat_buf_access(fat_fs_info_t *fs_info, uint32_t blk, int op_type, rtems_bdbuf_buffer **buf) {
   227e4:	e92d45f1 	push	{r0, r4, r5, r6, r7, r8, sl, lr}             <== NOT EXECUTED
   227e8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
    uint8_t           i;                                              
    bool              sec_of_fat;                                     
                                                                      
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
   227ec:	e5d00081 	ldrb	r0, [r0, #129]	; 0x81                        <== NOT EXECUTED
   227f0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
#include "fat_fat_operations.h"                                       
                                                                      
int                                                                   
fat_buf_access(fat_fs_info_t *fs_info, uint32_t   blk, int op_type,   
               rtems_bdbuf_buffer **buf)                              
{                                                                     
   227f4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   227f8:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   227fc:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
    uint8_t           i;                                              
    bool              sec_of_fat;                                     
                                                                      
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
   22800:	1a00000f 	bne	22844 <fat_buf_access+0x60>                   <== NOT EXECUTED
    {                                                                 
        if (op_type == FAT_OP_TYPE_READ)                              
   22804:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
   22808:	e2841054 	add	r1, r4, #84	; 0x54                            <== NOT EXECUTED
   2280c:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   22810:	e2843084 	add	r3, r4, #132	; 0x84                           <== NOT EXECUTED
   22814:	1a000002 	bne	22824 <fat_buf_access+0x40>                   <== NOT EXECUTED
            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
   22818:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   2281c:	ebff8ab1 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
   22820:	ea000001 	b	2282c <fat_buf_access+0x48>                     <== NOT EXECUTED
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
   22824:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   22828:	ebff8a7b 	bl	521c <rtems_bdbuf_get>                         <== NOT EXECUTED
        if (sc != RTEMS_SUCCESSFUL)                                   
   2282c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22830:	1a000058 	bne	22998 <fat_buf_access+0x1b4>                  <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = blk;                                     
        fs_info->c.modified = 0;                                      
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
   22834:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = blk;                                     
        fs_info->c.modified = 0;                                      
   22838:	e5c40080 	strb	r0, [r4, #128]	; 0x80                        <== NOT EXECUTED
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
   2283c:	e5c43081 	strb	r3, [r4, #129]	; 0x81                        <== NOT EXECUTED
            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = blk;                                     
   22840:	e584507c 	str	r5, [r4, #124]	; 0x7c                         <== NOT EXECUTED
        fs_info->c.modified = 0;                                      
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
    }                                                                 
                                                                      
    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&     
   22844:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   22848:	e1d421b4 	ldrh	r2, [r4, #20]                                <== NOT EXECUTED
   2284c:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   22850:	33a06000 	movcc	r6, #0                                      <== NOT EXECUTED
   22854:	3a000003 	bcc	22868 <fat_buf_access+0x84>                   <== NOT EXECUTED
   22858:	e594601c 	ldr	r6, [r4, #28]                                 <== NOT EXECUTED
   2285c:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
   22860:	23a06000 	movcs	r6, #0                                      <== NOT EXECUTED
   22864:	33a06001 	movcc	r6, #1                                      <== NOT EXECUTED
                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));      
                                                                      
    if (fs_info->c.blk_num != blk)                                    
   22868:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
   2286c:	0a00004e 	beq	229ac <fat_buf_access+0x1c8>                  <== NOT EXECUTED
    {                                                                 
        if (fs_info->c.modified)                                      
   22870:	e5d48080 	ldrb	r8, [r4, #128]	; 0x80                        <== NOT EXECUTED
   22874:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   22878:	0a000032 	beq	22948 <fat_buf_access+0x164>                  <== NOT EXECUTED
        {                                                             
            if (sec_of_fat && !fs_info->vol.mirror)                   
   2287c:	e21660ff 	ands	r6, r6, #255	; 0xff                          <== NOT EXECUTED
   22880:	0a000006 	beq	228a0 <fat_buf_access+0xbc>                   <== NOT EXECUTED
   22884:	e5d43048 	ldrb	r3, [r4, #72]	; 0x48                         <== NOT EXECUTED
   22888:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,      
   2288c:	05943084 	ldreq	r3, [r4, #132]	; 0x84                       <== NOT EXECUTED
   22890:	05940088 	ldreq	r0, [r4, #136]	; 0x88                       <== NOT EXECUTED
   22894:	05931020 	ldreq	r1, [r3, #32]                               <== NOT EXECUTED
   22898:	01d420b0 	ldrheq	r2, [r4]                                   <== NOT EXECUTED
   2289c:	0b007647 	bleq	401c0 <memcpy>                               <== NOT EXECUTED
                       fs_info->vol.bps);                             
                                                                      
            sc = rtems_bdbuf_release_modified(fs_info->c.buf);        
   228a0:	e5940084 	ldr	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
   228a4:	ebff862d 	bl	4160 <rtems_bdbuf_release_modified>            <== NOT EXECUTED
            fs_info->c.state = FAT_CACHE_EMPTY;                       
   228a8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
            fs_info->c.modified = 0;                                  
            if (sc != RTEMS_SUCCESSFUL)                               
   228ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,      
                       fs_info->vol.bps);                             
                                                                      
            sc = rtems_bdbuf_release_modified(fs_info->c.buf);        
            fs_info->c.state = FAT_CACHE_EMPTY;                       
            fs_info->c.modified = 0;                                  
   228b0:	e5c43080 	strb	r3, [r4, #128]	; 0x80                        <== NOT EXECUTED
            if (sec_of_fat && !fs_info->vol.mirror)                   
                memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,      
                       fs_info->vol.bps);                             
                                                                      
            sc = rtems_bdbuf_release_modified(fs_info->c.buf);        
            fs_info->c.state = FAT_CACHE_EMPTY;                       
   228b4:	e5c43081 	strb	r3, [r4, #129]	; 0x81                        <== NOT EXECUTED
            fs_info->c.modified = 0;                                  
            if (sc != RTEMS_SUCCESSFUL)                               
   228b8:	1a000036 	bne	22998 <fat_buf_access+0x1b4>                  <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one(EIO);            
                                                                      
            if (sec_of_fat && !fs_info->vol.mirror)                   
   228bc:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   228c0:	0a000025 	beq	2295c <fat_buf_access+0x178>                  <== NOT EXECUTED
   228c4:	e5d43048 	ldrb	r3, [r4, #72]	; 0x48                         <== NOT EXECUTED
   228c8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   228cc:	03a06001 	moveq	r6, #1                                      <== NOT EXECUTED
            {                                                         
                rtems_bdbuf_buffer *b;                                
                                                                      
                for (i = 1; i < fs_info->vol.fats; i++)               
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dev,            
   228d0:	01a0800d 	moveq	r8, sp                                      <== NOT EXECUTED
            fs_info->c.state = FAT_CACHE_EMPTY;                       
            fs_info->c.modified = 0;                                  
            if (sc != RTEMS_SUCCESSFUL)                               
                rtems_set_errno_and_return_minus_one(EIO);            
                                                                      
            if (sec_of_fat && !fs_info->vol.mirror)                   
   228d4:	0a000016 	beq	22934 <fat_buf_access+0x150>                  <== NOT EXECUTED
   228d8:	ea00001f 	b	2295c <fat_buf_access+0x178>                    <== NOT EXECUTED
            {                                                         
                rtems_bdbuf_buffer *b;                                
                                                                      
                for (i = 1; i < fs_info->vol.fats; i++)               
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dev,            
   228dc:	e5941018 	ldr	r1, [r4, #24]                                 <== NOT EXECUTED
   228e0:	e594207c 	ldr	r2, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   228e4:	e0222691 	mla	r2, r1, r6, r2                                <== NOT EXECUTED
   228e8:	e2841054 	add	r1, r4, #84	; 0x54                            <== NOT EXECUTED
   228ec:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   228f0:	ebff8a49 	bl	521c <rtems_bdbuf_get>                         <== NOT EXECUTED
                                         fs_info->c.blk_num +         
                                         fs_info->vol.fat_length * i, 
                                         &b);                         
                    if ( sc != RTEMS_SUCCESSFUL)                      
   228f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   228f8:	1a000008 	bne	22920 <fat_buf_access+0x13c>                  <== NOT EXECUTED
                        rtems_set_errno_and_return_minus_one(ENOMEM); 
                    memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
   228fc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   22900:	e5941088 	ldr	r1, [r4, #136]	; 0x88                         <== NOT EXECUTED
   22904:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   22908:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
   2290c:	eb00762b 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                    sc = rtems_bdbuf_release_modified(b);             
   22910:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
   22914:	ebff8611 	bl	4160 <rtems_bdbuf_release_modified>            <== NOT EXECUTED
                    if ( sc != RTEMS_SUCCESSFUL)                      
   22918:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   2291c:	0a000002 	beq	2292c <fat_buf_access+0x148>                  <== NOT EXECUTED
                        rtems_set_errno_and_return_minus_one(ENOMEM); 
   22920:	eb006976 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22924:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   22928:	ea00001c 	b	229a0 <fat_buf_access+0x1bc>                    <== NOT EXECUTED
                                                                      
            if (sec_of_fat && !fs_info->vol.mirror)                   
            {                                                         
                rtems_bdbuf_buffer *b;                                
                                                                      
                for (i = 1; i < fs_info->vol.fats; i++)               
   2292c:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   22930:	e20660ff 	and	r6, r6, #255	; 0xff                           <== NOT EXECUTED
   22934:	e5d42009 	ldrb	r2, [r4, #9]                                 <== NOT EXECUTED
   22938:	e1520006 	cmp	r2, r6                                        <== NOT EXECUTED
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dev,            
   2293c:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
                                                                      
            if (sec_of_fat && !fs_info->vol.mirror)                   
            {                                                         
                rtems_bdbuf_buffer *b;                                
                                                                      
                for (i = 1; i < fs_info->vol.fats; i++)               
   22940:	8affffe5 	bhi	228dc <fat_buf_access+0xf8>                   <== NOT EXECUTED
   22944:	ea000004 	b	2295c <fat_buf_access+0x178>                    <== NOT EXECUTED
                }                                                     
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            sc = rtems_bdbuf_release(fs_info->c.buf);                 
   22948:	e5940084 	ldr	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
   2294c:	ebff8625 	bl	41e8 <rtems_bdbuf_release>                     <== NOT EXECUTED
            fs_info->c.state = FAT_CACHE_EMPTY;                       
            if (sc != RTEMS_SUCCESSFUL)                               
   22950:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            sc = rtems_bdbuf_release(fs_info->c.buf);                 
            fs_info->c.state = FAT_CACHE_EMPTY;                       
   22954:	e5c48081 	strb	r8, [r4, #129]	; 0x81                        <== NOT EXECUTED
            if (sc != RTEMS_SUCCESSFUL)                               
   22958:	1a00000e 	bne	22998 <fat_buf_access+0x1b4>                  <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one(EIO);            
                                                                      
        }                                                             
        if (op_type == FAT_OP_TYPE_READ)                              
   2295c:	e3570001 	cmp	r7, #1                                        <== NOT EXECUTED
   22960:	e2841054 	add	r1, r4, #84	; 0x54                            <== NOT EXECUTED
   22964:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   22968:	e2843084 	add	r3, r4, #132	; 0x84                           <== NOT EXECUTED
   2296c:	1a000002 	bne	2297c <fat_buf_access+0x198>                  <== NOT EXECUTED
            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
   22970:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   22974:	ebff8a5b 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
   22978:	ea000001 	b	22984 <fat_buf_access+0x1a0>                    <== NOT EXECUTED
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
   2297c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   22980:	ebff8a25 	bl	521c <rtems_bdbuf_get>                         <== NOT EXECUTED
        if (sc != RTEMS_SUCCESSFUL)                                   
   22984:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = blk;                                     
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
   22988:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = blk;                                     
   2298c:	0584507c 	streq	r5, [r4, #124]	; 0x7c                       <== NOT EXECUTED
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
   22990:	05c43081 	strbeq	r3, [r4, #129]	; 0x81                      <== NOT EXECUTED
        }                                                             
        if (op_type == FAT_OP_TYPE_READ)                              
            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
   22994:	0a000004 	beq	229ac <fat_buf_access+0x1c8>                  <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
   22998:	eb006958 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   2299c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   229a0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   229a4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   229a8:	ea000002 	b	229b8 <fat_buf_access+0x1d4>                    <== NOT EXECUTED
        fs_info->c.blk_num = blk;                                     
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
    }                                                                 
    *buf = fs_info->c.buf;                                            
   229ac:	e5943084 	ldr	r3, [r4, #132]	; 0x84                         <== NOT EXECUTED
   229b0:	e58a3000 	str	r3, [sl]                                      <== NOT EXECUTED
   229b4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   229b8:	e8bd85f8 	pop	{r3, r4, r5, r6, r7, r8, sl, pc}              <== NOT EXECUTED
                                                                      

000226a4 <fat_buf_release>: return RC_OK; } int fat_buf_release(fat_fs_info_t *fs_info) {
   226a4:	e92d4071 	push	{r0, r4, r5, r6, lr}                         <== NOT EXECUTED
   226a8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
    uint8_t           i;                                              
    bool              sec_of_fat;                                     
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
   226ac:	e5d00081 	ldrb	r0, [r0, #129]	; 0x81                        <== NOT EXECUTED
   226b0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   226b4:	0a000047 	beq	227d8 <fat_buf_release+0x134>                 <== NOT EXECUTED
        return RC_OK;                                                 
                                                                      
    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&     
   226b8:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   226bc:	e1d421b4 	ldrh	r2, [r4, #20]                                <== NOT EXECUTED
   226c0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   226c4:	33a05000 	movcc	r5, #0                                      <== NOT EXECUTED
   226c8:	3a000003 	bcc	226dc <fat_buf_release+0x38>                  <== NOT EXECUTED
   226cc:	e594501c 	ldr	r5, [r4, #28]                                 <== NOT EXECUTED
   226d0:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
   226d4:	23a05000 	movcs	r5, #0                                      <== NOT EXECUTED
   226d8:	33a05001 	movcc	r5, #1                                      <== NOT EXECUTED
                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));      
                                                                      
    if (fs_info->c.modified)                                          
   226dc:	e5d43080 	ldrb	r3, [r4, #128]	; 0x80                        <== NOT EXECUTED
   226e0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   226e4:	0a000032 	beq	227b4 <fat_buf_release+0x110>                 <== NOT EXECUTED
    {                                                                 
        if (sec_of_fat && !fs_info->vol.mirror)                       
   226e8:	e21550ff 	ands	r5, r5, #255	; 0xff                          <== NOT EXECUTED
   226ec:	0a000006 	beq	2270c <fat_buf_release+0x68>                  <== NOT EXECUTED
   226f0:	e5d43048 	ldrb	r3, [r4, #72]	; 0x48                         <== NOT EXECUTED
   226f4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
   226f8:	05943084 	ldreq	r3, [r4, #132]	; 0x84                       <== NOT EXECUTED
   226fc:	05940088 	ldreq	r0, [r4, #136]	; 0x88                       <== NOT EXECUTED
   22700:	05931020 	ldreq	r1, [r3, #32]                               <== NOT EXECUTED
   22704:	01d420b0 	ldrheq	r2, [r4]                                   <== NOT EXECUTED
   22708:	0b0076ac 	bleq	401c0 <memcpy>                               <== NOT EXECUTED
                                                                      
        sc = rtems_bdbuf_release_modified(fs_info->c.buf);            
   2270c:	e5940084 	ldr	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
   22710:	ebff8692 	bl	4160 <rtems_bdbuf_release_modified>            <== NOT EXECUTED
        if (sc != RTEMS_SUCCESSFUL)                                   
   22714:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22718:	1a000029 	bne	227c4 <fat_buf_release+0x120>                 <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.modified = 0;                                      
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
   2271c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
            memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
                                                                      
        sc = rtems_bdbuf_release_modified(fs_info->c.buf);            
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.modified = 0;                                      
   22720:	e5c40080 	strb	r0, [r4, #128]	; 0x80                        <== NOT EXECUTED
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
   22724:	0a000029 	beq	227d0 <fat_buf_release+0x12c>                 <== NOT EXECUTED
   22728:	e5d43048 	ldrb	r3, [r4, #72]	; 0x48                         <== NOT EXECUTED
   2272c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   22730:	03a05001 	moveq	r5, #1                                      <== NOT EXECUTED
        {                                                             
            rtems_bdbuf_buffer *b;                                    
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
            {                                                         
                sc = rtems_bdbuf_get(fs_info->vol.dev,                
   22734:	01a0600d 	moveq	r6, sp                                      <== NOT EXECUTED
        sc = rtems_bdbuf_release_modified(fs_info->c.buf);            
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.modified = 0;                                      
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
   22738:	0a000018 	beq	227a0 <fat_buf_release+0xfc>                  <== NOT EXECUTED
   2273c:	ea000023 	b	227d0 <fat_buf_release+0x12c>                   <== NOT EXECUTED
        {                                                             
            rtems_bdbuf_buffer *b;                                    
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
            {                                                         
                sc = rtems_bdbuf_get(fs_info->vol.dev,                
   22740:	e5941018 	ldr	r1, [r4, #24]                                 <== NOT EXECUTED
   22744:	e594207c 	ldr	r2, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   22748:	e0222591 	mla	r2, r1, r5, r2                                <== NOT EXECUTED
   2274c:	e2841054 	add	r1, r4, #84	; 0x54                            <== NOT EXECUTED
   22750:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   22754:	ebff8ab0 	bl	521c <rtems_bdbuf_get>                         <== NOT EXECUTED
                                     fs_info->c.blk_num +             
                                     fs_info->vol.fat_length * i,     
                                     &b);                             
                if ( sc != RTEMS_SUCCESSFUL)                          
   22758:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   2275c:	0a000004 	beq	22774 <fat_buf_release+0xd0>                  <== NOT EXECUTED
                    rtems_set_errno_and_return_minus_one(ENOMEM);     
   22760:	eb0069e6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22764:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   22768:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   2276c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   22770:	ea000018 	b	227d8 <fat_buf_release+0x134>                   <== NOT EXECUTED
                memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
   22774:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   22778:	e5941088 	ldr	r1, [r4, #136]	; 0x88                         <== NOT EXECUTED
   2277c:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   22780:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
   22784:	eb00768d 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                sc = rtems_bdbuf_release_modified(b);                 
   22788:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
   2278c:	ebff8673 	bl	4160 <rtems_bdbuf_release_modified>            <== NOT EXECUTED
                if ( sc != RTEMS_SUCCESSFUL)                          
   22790:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22794:	1afffff1 	bne	22760 <fat_buf_release+0xbc>                  <== NOT EXECUTED
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
        {                                                             
            rtems_bdbuf_buffer *b;                                    
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
   22798:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
   2279c:	e20550ff 	and	r5, r5, #255	; 0xff                           <== NOT EXECUTED
   227a0:	e5d42009 	ldrb	r2, [r4, #9]                                 <== NOT EXECUTED
   227a4:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
            {                                                         
                sc = rtems_bdbuf_get(fs_info->vol.dev,                
   227a8:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
        {                                                             
            rtems_bdbuf_buffer *b;                                    
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
   227ac:	8affffe3 	bhi	22740 <fat_buf_release+0x9c>                  <== NOT EXECUTED
   227b0:	ea000006 	b	227d0 <fat_buf_release+0x12c>                   <== NOT EXECUTED
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
   227b4:	e5940084 	ldr	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
   227b8:	ebff868a 	bl	41e8 <rtems_bdbuf_release>                     <== NOT EXECUTED
        if (sc != RTEMS_SUCCESSFUL)                                   
   227bc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   227c0:	0a000002 	beq	227d0 <fat_buf_release+0x12c>                 <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
   227c4:	eb0069cd 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   227c8:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   227cc:	eaffffe5 	b	22768 <fat_buf_release+0xc4>                    <== NOT EXECUTED
    }                                                                 
    fs_info->c.state = FAT_CACHE_EMPTY;                               
   227d0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   227d4:	e5c40081 	strb	r0, [r4, #129]	; 0x81                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   227d8:	e8bd8078 	pop	{r3, r4, r5, r6, pc}                          <== NOT EXECUTED
                                                                      

00023328 <fat_cluster_read>: uint32_t cln ) { register fat_fs_info_t *fs_info = mt_entry->fs_info; if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   23328:	e2513000 	subs	r3, r1, #0                                   <== NOT EXECUTED
fat_cluster_read(                                                     
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    void                                 *buff                        
    )                                                                 
{                                                                     
   2332c:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
   23330:	e92d4001 	push	{r0, lr}                                     <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   23334:	e5902034 	ldr	r2, [r0, #52]	; 0x34                          <== NOT EXECUTED
   23338:	1a000003 	bne	2334c <fat_cluster_read+0x24>                 <== NOT EXECUTED
   2333c:	e5d2100a 	ldrb	r1, [r2, #10]                                <== NOT EXECUTED
   23340:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   23344:	1592101c 	ldrne	r1, [r2, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   23348:	1a000003 	bne	2335c <fat_cluster_read+0x34>                 <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   2334c:	e5d21005 	ldrb	r1, [r2, #5]                                 <== NOT EXECUTED
   23350:	e592e030 	ldr	lr, [r2, #48]	; 0x30                          <== NOT EXECUTED
   23354:	e2433002 	sub	r3, r3, #2                                    <== NOT EXECUTED
   23358:	e08e1113 	add	r1, lr, r3, lsl r1                            <== NOT EXECUTED
    uint32_t       fsec = 0;                                          
                                                                      
    fsec = fat_cluster_num_to_sector_num(mt_entry, cln);              
                                                                      
    return _fat_block_read(mt_entry, fsec, 0,                         
   2335c:	e5d23002 	ldrb	r3, [r2, #2]                                 <== NOT EXECUTED
   23360:	e5d22004 	ldrb	r2, [r2, #4]                                 <== NOT EXECUTED
   23364:	e1a03312 	lsl	r3, r2, r3                                    <== NOT EXECUTED
   23368:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   2336c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   23370:	ebfffe4c 	bl	22ca8 <_fat_block_read>                        <== NOT EXECUTED
                           fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}                                                                     
   23374:	e8bd8008 	pop	{r3, pc}                                      <== NOT EXECUTED
                                                                      

00022bb0 <fat_cluster_write>: uint32_t cln ) { register fat_fs_info_t *fs_info = mt_entry->fs_info; if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22bb0:	e2513000 	subs	r3, r1, #0                                   <== NOT EXECUTED
fat_cluster_write(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    const void                           *buff                        
    )                                                                 
{                                                                     
   22bb4:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
   22bb8:	e92d4001 	push	{r0, lr}                                     <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   22bbc:	e5902034 	ldr	r2, [r0, #52]	; 0x34                          <== NOT EXECUTED
   22bc0:	1a000003 	bne	22bd4 <fat_cluster_write+0x24>                <== NOT EXECUTED
   22bc4:	e5d2100a 	ldrb	r1, [r2, #10]                                <== NOT EXECUTED
   22bc8:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   22bcc:	1592101c 	ldrne	r1, [r2, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22bd0:	1a000003 	bne	22be4 <fat_cluster_write+0x34>                <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22bd4:	e5d21005 	ldrb	r1, [r2, #5]                                 <== NOT EXECUTED
   22bd8:	e592e030 	ldr	lr, [r2, #48]	; 0x30                          <== NOT EXECUTED
   22bdc:	e2433002 	sub	r3, r3, #2                                    <== NOT EXECUTED
   22be0:	e08e1113 	add	r1, lr, r3, lsl r1                            <== NOT EXECUTED
    uint32_t       fsec = 0;                                          
                                                                      
    fsec = fat_cluster_num_to_sector_num(mt_entry, cln);              
                                                                      
    return _fat_block_write(mt_entry, fsec, 0,                        
   22be4:	e5d23002 	ldrb	r3, [r2, #2]                                 <== NOT EXECUTED
   22be8:	e5d22004 	ldrb	r2, [r2, #4]                                 <== NOT EXECUTED
   22bec:	e1a03312 	lsl	r3, r2, r3                                    <== NOT EXECUTED
   22bf0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   22bf4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   22bf8:	ebffff6f 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                          fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}                                                                     
   22bfc:	e8bd8008 	pop	{r3, pc}                                      <== NOT EXECUTED
                                                                      

00022a6c <fat_fat32_update_fsinfo_sector>: fat_fat32_update_fsinfo_sector( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t free_count, uint32_t next_free ) {
   22a6c:	e92d4077 	push	{r0, r1, r2, r4, r5, r6, lr}                 <== NOT EXECUTED
    ssize_t                 ret1 = 0, ret2 = 0;                       
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   22a70:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t                le_next_free = 0;                         
                                                                      
    le_free_count = CT_LE_L(free_count);                              
    le_next_free = CT_LE_L(next_free);                                
                                                                      
    ret1 = _fat_block_write(mt_entry,                                 
   22a74:	e1d533bc 	ldrh	r3, [r5, #60]	; 0x3c                         <== NOT EXECUTED
   22a78:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
    ssize_t                 ret1 = 0, ret2 = 0;                       
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
    uint32_t                le_free_count = 0;                        
    uint32_t                le_next_free = 0;                         
                                                                      
    le_free_count = CT_LE_L(free_count);                              
   22a7c:	e58d1008 	str	r1, [sp, #8]                                  <== NOT EXECUTED
    le_next_free = CT_LE_L(next_free);                                
   22a80:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
                                                                      
    ret1 = _fat_block_write(mt_entry,                                 
   22a84:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   22a88:	e3a02f7a 	mov	r2, #488	; 0x1e8                              <== NOT EXECUTED
   22a8c:	e3a03004 	mov	r3, #4                                        <== NOT EXECUTED
fat_fat32_update_fsinfo_sector(                                       
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              free_count,                 
    uint32_t                              next_free                   
    )                                                                 
{                                                                     
   22a90:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    uint32_t                le_next_free = 0;                         
                                                                      
    le_free_count = CT_LE_L(free_count);                              
    le_next_free = CT_LE_L(next_free);                                
                                                                      
    ret1 = _fat_block_write(mt_entry,                                 
   22a94:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   22a98:	ebffffc7 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                            fs_info->vol.info_sec,                    
                            FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,     
                            4,                                        
                            (char *)(&le_free_count));                
                                                                      
    ret2 = _fat_block_write(mt_entry,                                 
   22a9c:	e3a03004 	mov	r3, #4                                        <== NOT EXECUTED
   22aa0:	e1d513bc 	ldrh	r1, [r5, #60]	; 0x3c                         <== NOT EXECUTED
   22aa4:	e08dc003 	add	ip, sp, r3                                    <== NOT EXECUTED
    uint32_t                le_next_free = 0;                         
                                                                      
    le_free_count = CT_LE_L(free_count);                              
    le_next_free = CT_LE_L(next_free);                                
                                                                      
    ret1 = _fat_block_write(mt_entry,                                 
   22aa8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                            fs_info->vol.info_sec,                    
                            FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,     
                            4,                                        
                            (char *)(&le_free_count));                
                                                                      
    ret2 = _fat_block_write(mt_entry,                                 
   22aac:	e3a02f7b 	mov	r2, #492	; 0x1ec                              <== NOT EXECUTED
   22ab0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22ab4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   22ab8:	ebffffbf 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                            fs_info->vol.info_sec,                    
                            FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,      
                            4,                                        
                            (char *)(&le_next_free));                 
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) )                                   
   22abc:	e1a06fa6 	lsr	r6, r6, #31                                   <== NOT EXECUTED
   22ac0:	e1960fa0 	orrs	r0, r6, r0, lsr #31                          <== NOT EXECUTED
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
   22ac4:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
   22ac8:	e8bd807e 	pop	{r1, r2, r3, r4, r5, r6, pc}                  <== NOT EXECUTED
                                                                      

000222b8 <fat_file_close>: /* * if links_num field of fat-file descriptor is greater than 1 * decrement the count of links and return */ if (fat_fd->links_num > 1)
   222b8:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
   222bc:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
int                                                                   
fat_file_close(                                                       
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   222c0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   222c4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   222c8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   222cc:	e5906034 	ldr	r6, [r0, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    /*                                                                
     * if links_num field of fat-file descriptor is greater than 1    
     * decrement the count of links and return                        
     */                                                               
    if (fat_fd->links_num > 1)                                        
   222d0:	9a000003 	bls	222e4 <fat_file_close+0x2c>                   <== NOT EXECUTED
    {                                                                 
        fat_fd->links_num--;                                          
   222d4:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   222d8:	e5813008 	str	r3, [r1, #8]                                  <== NOT EXECUTED
   222dc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
        return rc;                                                    
   222e0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    }                                                                 
                                                                      
    key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);        
                                                                      
    if (fat_fd->flags & FAT_FILE_REMOVED)                             
   222e4:	e5d17030 	ldrb	r7, [r1, #48]	; 0x30                         <== NOT EXECUTED
   222e8:	e2177001 	ands	r7, r7, #1                                   <== NOT EXECUTED
   222ec:	0a00000e 	beq	2232c <fat_file_close+0x74>                   <== NOT EXECUTED
    {                                                                 
        rc = fat_file_truncate(mt_entry, fat_fd, 0);                  
   222f0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   222f4:	ebfffe36 	bl	21bd4 <fat_file_truncate>                      <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   222f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   222fc:	18bd80f0 	popne	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
   22300:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22304:	ebffa84d 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
            return rc;                                                
                                                                      
        _hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);       
                                                                      
        if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )               
   22308:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   2230c:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
   22310:	eb0000af 	bl	225d4 <fat_ino_is_unique>                      <== NOT EXECUTED
   22314:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22318:	0a00000a 	beq	22348 <fat_file_close+0x90>                   <== NOT EXECUTED
            fat_free_unique_ino(mt_entry, fat_fd->ino);               
   2231c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   22320:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
   22324:	eb0000a0 	bl	225ac <fat_free_unique_ino>                    <== NOT EXECUTED
   22328:	ea000006 	b	22348 <fat_file_close+0x90>                     <== NOT EXECUTED
                                                                      
        free(fat_fd);                                                 
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_ino_is_unique(mt_entry, fat_fd->ino))                 
   2232c:	e591100c 	ldr	r1, [r1, #12]                                 <== NOT EXECUTED
   22330:	eb0000a7 	bl	225d4 <fat_ino_is_unique>                      <== NOT EXECUTED
   22334:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        {                                                             
            fat_fd->links_num = 0;                                    
   22338:	15847008 	strne	r7, [r4, #8]                                <== NOT EXECUTED
                                                                      
        free(fat_fd);                                                 
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_ino_is_unique(mt_entry, fat_fd->ino))                 
   2233c:	1a000003 	bne	22350 <fat_file_close+0x98>                   <== NOT EXECUTED
   22340:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22344:	ebffa83d 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
            fat_fd->links_num = 0;                                    
        }                                                             
        else                                                          
        {                                                             
            _hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);   
            free(fat_fd);                                             
   22348:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   2234c:	ebff94d8 	bl	76b4 <free>                                    <== NOT EXECUTED
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
   22350:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
    return rc;                                                        
}                                                                     
   22354:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
   22358:	ea0000d1 	b	226a4 <fat_buf_release>                         <== NOT EXECUTED
                                                                      

000219d0 <fat_file_datasync>: int fat_file_datasync( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd ) {
   219d0:	e92d47f3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, lr}     <== NOT EXECUTED
    uint32_t            cur_cln = fat_fd->cln;                        
    rtems_bdbuf_buffer *block = NULL;                                 
    uint32_t            sec = 0;                                      
    uint32_t            i = 0;                                        
                                                                      
    if (fat_fd->fat_file_size == 0)                                   
   219d4:	e5914018 	ldr	r4, [r1, #24]                                 <== NOT EXECUTED
   219d8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
int                                                                   
fat_file_datasync(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   219dc:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    int                 rc = RC_OK;                                   
    rtems_status_code   sc = RTEMS_SUCCESSFUL;                        
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
   219e0:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t            cur_cln = fat_fd->cln;                        
   219e4:	e591301c 	ldr	r3, [r1, #28]                                 <== NOT EXECUTED
    rtems_bdbuf_buffer *block = NULL;                                 
    uint32_t            sec = 0;                                      
    uint32_t            i = 0;                                        
                                                                      
    if (fat_fd->fat_file_size == 0)                                   
   219e8:	0a000036 	beq	21ac8 <fat_file_datasync+0xf8>                <== NOT EXECUTED
{                                                                     
    int                 rc = RC_OK;                                   
    rtems_status_code   sc = RTEMS_SUCCESSFUL;                        
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
    uint32_t            cur_cln = fat_fd->cln;                        
    rtems_bdbuf_buffer *block = NULL;                                 
   219ec:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     * we can use only one bdbuf :( and we also know that cache is useless
     * for sync operation, so don't use it                            
     */                                                               
    rc = fat_buf_release(fs_info);                                    
   219f0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
{                                                                     
    int                 rc = RC_OK;                                   
    rtems_status_code   sc = RTEMS_SUCCESSFUL;                        
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
    uint32_t            cur_cln = fat_fd->cln;                        
    rtems_bdbuf_buffer *block = NULL;                                 
   219f4:	e88d000c 	stm	sp, {r2, r3}                                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * we can use only one bdbuf :( and we also know that cache is useless
     * for sync operation, so don't use it                            
     */                                                               
    rc = fat_buf_release(fs_info);                                    
   219f8:	eb000329 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   219fc:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        /* for each sector in cluster ... */                          
        for ( i = 0; i < fs_info->vol.spc; i++ )                      
        {                                                             
            /* ... sync it */                                         
            sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
   21a00:	01a0a00d 	moveq	sl, sp                                      <== NOT EXECUTED
            sc = rtems_bdbuf_sync(block);                             
            if ( sc != RTEMS_SUCCESSFUL )                             
                rtems_set_errno_and_return_minus_one( EIO );          
        }                                                             
                                                                      
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   21a04:	028d9004 	addeq	r9, sp, #4                                  <== NOT EXECUTED
    /*                                                                
     * we can use only one bdbuf :( and we also know that cache is useless
     * for sync operation, so don't use it                            
     */                                                               
    rc = fat_buf_release(fs_info);                                    
    if (rc != RC_OK)                                                  
   21a08:	0a000028 	beq	21ab0 <fat_file_datasync+0xe0>                <== NOT EXECUTED
   21a0c:	ea00002d 	b	21ac8 <fat_file_datasync+0xf8>                  <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   21a10:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   21a14:	e5972034 	ldr	r2, [r7, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   21a18:	1a000003 	bne	21a2c <fat_file_datasync+0x5c>                <== NOT EXECUTED
   21a1c:	e5d2100a 	ldrb	r1, [r2, #10]                                <== NOT EXECUTED
   21a20:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   21a24:	1592801c 	ldrne	r8, [r2, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   21a28:	1a000003 	bne	21a3c <fat_file_datasync+0x6c>                <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   21a2c:	e5921030 	ldr	r1, [r2, #48]	; 0x30                          <== NOT EXECUTED
   21a30:	e5d22005 	ldrb	r2, [r2, #5]                                 <== NOT EXECUTED
   21a34:	e2438002 	sub	r8, r3, #2                                    <== NOT EXECUTED
   21a38:	e0818218 	add	r8, r1, r8, lsl r2                            <== NOT EXECUTED
   21a3c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
    /* for each cluster of the file ... */                            
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        /* for each sector in cluster ... */                          
        for ( i = 0; i < fs_info->vol.spc; i++ )                      
   21a40:	ea00000e 	b	21a80 <fat_file_datasync+0xb0>                  <== NOT EXECUTED
        {                                                             
            /* ... sync it */                                         
            sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
   21a44:	e2851054 	add	r1, r5, #84	; 0x54                            <== NOT EXECUTED
   21a48:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   21a4c:	ebff8e25 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
            if (sc != RTEMS_SUCCESSFUL)                               
   21a50:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21a54:	1a000003 	bne	21a68 <fat_file_datasync+0x98>                <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EIO );          
                                                                      
            sc = rtems_bdbuf_sync(block);                             
   21a58:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
   21a5c:	ebff8c16 	bl	4abc <rtems_bdbuf_sync>                        <== NOT EXECUTED
            if ( sc != RTEMS_SUCCESSFUL )                             
   21a60:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21a64:	0a000004 	beq	21a7c <fat_file_datasync+0xac>                <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EIO );          
   21a68:	eb006d24 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   21a6c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   21a70:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   21a74:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   21a78:	ea000012 	b	21ac8 <fat_file_datasync+0xf8>                  <== NOT EXECUTED
    /* for each cluster of the file ... */                            
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        /* for each sector in cluster ... */                          
        for ( i = 0; i < fs_info->vol.spc; i++ )                      
   21a7c:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   21a80:	e5d51004 	ldrb	r1, [r5, #4]                                 <== NOT EXECUTED
   21a84:	e1560001 	cmp	r6, r1                                        <== NOT EXECUTED
        {                                                             
            /* ... sync it */                                         
            sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
   21a88:	e0862008 	add	r2, r6, r8                                    <== NOT EXECUTED
   21a8c:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
    /* for each cluster of the file ... */                            
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        /* for each sector in cluster ... */                          
        for ( i = 0; i < fs_info->vol.spc; i++ )                      
   21a90:	3affffeb 	bcc	21a44 <fat_file_datasync+0x74>                <== NOT EXECUTED
            sc = rtems_bdbuf_sync(block);                             
            if ( sc != RTEMS_SUCCESSFUL )                             
                rtems_set_errno_and_return_minus_one( EIO );          
        }                                                             
                                                                      
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   21a94:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   21a98:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   21a9c:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   21aa0:	eb005e1c 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   21aa4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21aa8:	11a04000 	movne	r4, r0                                      <== NOT EXECUTED
   21aac:	1a000005 	bne	21ac8 <fat_file_datasync+0xf8>                <== NOT EXECUTED
    rc = fat_buf_release(fs_info);                                    
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    /* for each cluster of the file ... */                            
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   21ab0:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   21ab4:	e285100c 	add	r1, r5, #12                                   <== NOT EXECUTED
   21ab8:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
   21abc:	e0031001 	and	r1, r3, r1                                    <== NOT EXECUTED
   21ac0:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
   21ac4:	3affffd1 	bcc	21a10 <fat_file_datasync+0x40>                <== NOT EXECUTED
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
        if ( rc != RC_OK )                                            
            return rc;                                                
    }                                                                 
    return rc;                                                        
}                                                                     
   21ac8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   21acc:	e8bd87fc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}      <== NOT EXECUTED
                                                                      

00021ccc <fat_file_extend>: rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd, uint32_t new_length, uint32_t *a_length ) {
   21ccc:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   21cd0:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
    uint32_t       old_last_cl;                                       
    uint32_t       last_cl = 0;                                       
    uint32_t       bytes_remain = 0;                                  
    uint32_t       cls_added;                                         
                                                                      
    *a_length = new_length;                                           
   21cd4:	e58b2000 	str	r2, [fp]                                      <== NOT EXECUTED
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
   21cd8:	e5919018 	ldr	r9, [r1, #24]                                 <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              new_length,                 
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
   21cdc:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       chain = 0;                                         
   21ce0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    uint32_t       bytes_remain = 0;                                  
    uint32_t       cls_added;                                         
                                                                      
    *a_length = new_length;                                           
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
   21ce4:	e1520009 	cmp	r2, r9                                        <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              new_length,                 
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
   21ce8:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   21cec:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   21cf0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       chain = 0;                                         
    uint32_t       bytes2add = 0;                                     
    uint32_t       cls2add = 0;                                       
    uint32_t       old_last_cl;                                       
    uint32_t       last_cl = 0;                                       
   21cf4:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       chain = 0;                                         
   21cf8:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
    uint32_t                              new_length,                 
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   21cfc:	e5906034 	ldr	r6, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t       bytes_remain = 0;                                  
    uint32_t       cls_added;                                         
                                                                      
    *a_length = new_length;                                           
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
   21d00:	9a000061 	bls	21e8c <fat_file_extend+0x1c0>                 <== NOT EXECUTED
        return RC_OK;                                                 
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
   21d04:	e5913020 	ldr	r3, [r1, #32]                                 <== NOT EXECUTED
   21d08:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   21d0c:	1a000005 	bne	21d28 <fat_file_extend+0x5c>                  <== NOT EXECUTED
   21d10:	e5913024 	ldr	r3, [r1, #36]	; 0x24                          <== NOT EXECUTED
   21d14:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   21d18:	1a000002 	bne	21d28 <fat_file_extend+0x5c>                  <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
   21d1c:	e5d6300a 	ldrb	r3, [r6, #10]                                <== NOT EXECUTED
   21d20:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
   21d24:	1a00001a 	bne	21d94 <fat_file_extend+0xc8>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOSPC );               
                                                                      
    bytes_remain = (fs_info->vol.bpc -                                
   21d28:	e1d620b6 	ldrh	r2, [r6, #6]                                 <== NOT EXECUTED
                   (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
   21d2c:	e2423001 	sub	r3, r2, #1                                    <== NOT EXECUTED
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
        rtems_set_errno_and_return_minus_one( ENOSPC );               
                                                                      
    bytes_remain = (fs_info->vol.bpc -                                
   21d30:	e0038009 	and	r8, r3, r9                                    <== NOT EXECUTED
   21d34:	e0688002 	rsb	r8, r8, r2                                    <== NOT EXECUTED
   21d38:	e0088003 	and	r8, r8, r3                                    <== NOT EXECUTED
                   (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
                   (fs_info->vol.bpc - 1);                            
                                                                      
    bytes2add = new_length - fat_fd->fat_file_size;                   
   21d3c:	e0699007 	rsb	r9, r9, r7                                    <== NOT EXECUTED
                                                                      
    if (bytes2add > bytes_remain)                                     
   21d40:	e1590008 	cmp	r9, r8                                        <== NOT EXECUTED
   21d44:	9a000050 	bls	21e8c <fat_file_extend+0x1c0>                 <== NOT EXECUTED
    /*                                                                
     * if in last cluster allocated for the file there is enough room to
     * handle extention (hence we don't need to add even one cluster to the
     * file ) - return                                                
     */                                                               
    if (bytes2add == 0)                                               
   21d48:	e0599008 	subs	r9, r9, r8                                   <== NOT EXECUTED
   21d4c:	0a00004e 	beq	21e8c <fat_file_extend+0x1c0>                 <== NOT EXECUTED
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
   21d50:	e5d63008 	ldrb	r3, [r6, #8]                                 <== NOT EXECUTED
   21d54:	e249a001 	sub	sl, r9, #1                                    <== NOT EXECUTED
   21d58:	e1a0a33a 	lsr	sl, sl, r3                                    <== NOT EXECUTED
   21d5c:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
                                                                      
    rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,    
   21d60:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
   21d64:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   21d68:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
   21d6c:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   21d70:	e28d3004 	add	r3, sp, #4                                    <== NOT EXECUTED
   21d74:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   21d78:	eb005def 	bl	3953c <fat_scan_fat_for_free_clusters>         <== NOT EXECUTED
                                        &cls_added, &last_cl);        
                                                                      
    /* this means that low level I/O error occured */                 
    if (rc != RC_OK)                                                  
   21d7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21d80:	11a08000 	movne	r8, r0                                      <== NOT EXECUTED
   21d84:	1a000041 	bne	21e90 <fat_file_extend+0x1c4>                 <== NOT EXECUTED
        return rc;                                                    
                                                                      
    /* this means that no space left on device */                     
    if ((cls_added == 0) && (bytes_remain == 0))                      
   21d88:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   21d8c:	e1988003 	orrs	r8, r8, r3                                   <== NOT EXECUTED
   21d90:	1a000004 	bne	21da8 <fat_file_extend+0xdc>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOSPC);                 
   21d94:	eb006c59 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   21d98:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
   21d9c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   21da0:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
   21da4:	ea000039 	b	21e90 <fat_file_extend+0x1c4>                   <== NOT EXECUTED
                                                                      
    /*  check wether we satisfied request for 'cls2add' clusters */   
    if (cls2add != cls_added)                                         
   21da8:	e15a0003 	cmp	sl, r3                                        <== NOT EXECUTED
   21dac:	0a000008 	beq	21dd4 <fat_file_extend+0x108>                 <== NOT EXECUTED
        *a_length = new_length -                                      
   21db0:	e1e03003 	mvn	r3, r3                                        <== NOT EXECUTED
   21db4:	e5d62008 	ldrb	r2, [r6, #8]                                 <== NOT EXECUTED
   21db8:	e083a00a 	add	sl, r3, sl                                    <== NOT EXECUTED
   21dbc:	e047a21a 	sub	sl, r7, sl, lsl r2                            <== NOT EXECUTED
   21dc0:	e1d630b6 	ldrh	r3, [r6, #6]                                 <== NOT EXECUTED
   21dc4:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   21dc8:	e0099003 	and	r9, r9, r3                                    <== NOT EXECUTED
   21dcc:	e069900a 	rsb	r9, r9, sl                                    <== NOT EXECUTED
   21dd0:	e58b9000 	str	r9, [fp]                                      <== NOT EXECUTED
                    ((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
                    (bytes2add & (fs_info->vol.bpc - 1));             
                                                                      
    /* add new chain to the end of existed */                         
    if ( fat_fd->fat_file_size == 0 )                                 
   21dd4:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
   21dd8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    {                                                                 
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
   21ddc:	059d2010 	ldreq	r2, [sp, #16]                               <== NOT EXECUTED
        fat_fd->map.file_cln = 0;                                     
   21de0:	05843034 	streq	r3, [r4, #52]	; 0x34                        <== NOT EXECUTED
                    (bytes2add & (fs_info->vol.bpc - 1));             
                                                                      
    /* add new chain to the end of existed */                         
    if ( fat_fd->fat_file_size == 0 )                                 
    {                                                                 
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
   21de4:	05842038 	streq	r2, [r4, #56]	; 0x38                        <== NOT EXECUTED
   21de8:	0584201c 	streq	r2, [r4, #28]                               <== NOT EXECUTED
   21dec:	0a000014 	beq	21e44 <fat_file_extend+0x178>                 <== NOT EXECUTED
        fat_fd->map.file_cln = 0;                                     
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)              
   21df0:	e594203c 	ldr	r2, [r4, #60]	; 0x3c                          <== NOT EXECUTED
   21df4:	e3720001 	cmn	r2, #1                                        <== NOT EXECUTED
        {                                                             
            old_last_cl = fat_fd->map.last_cln;                       
   21df8:	158d200c 	strne	r2, [sp, #12]                               <== NOT EXECUTED
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
        fat_fd->map.file_cln = 0;                                     
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)              
   21dfc:	1a000008 	bne	21e24 <fat_file_extend+0x158>                 <== NOT EXECUTED
        {                                                             
            old_last_cl = fat_fd->map.last_cln;                       
        }                                                             
        else                                                          
        {                                                             
            rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,          
   21e00:	e28dc00c 	add	ip, sp, #12                                   <== NOT EXECUTED
   21e04:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   21e08:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   21e0c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   21e10:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   21e14:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   21e18:	ebffff3f 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                (fat_fd->fat_file_size - 1), &old_last_cl);
            if ( rc != RC_OK )                                        
   21e1c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   21e20:	1a000014 	bne	21e78 <fat_file_extend+0x1ac>                 <== NOT EXECUTED
                fat_free_fat_clusters_chain(mt_entry, chain);         
                return rc;                                            
            }                                                         
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);       
   21e24:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   21e28:	e28d100c 	add	r1, sp, #12                                   <== NOT EXECUTED
   21e2c:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
   21e30:	eb005ca0 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   21e34:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   21e38:	1a00000e 	bne	21e78 <fat_file_extend+0x1ac>                 <== NOT EXECUTED
        {                                                             
            fat_free_fat_clusters_chain(mt_entry, chain);             
            return rc;                                                
        }                                                             
        fat_buf_release(fs_info);                                     
   21e3c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   21e40:	eb000217 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* update number of the last cluster of the file if it changed */ 
    if (cls_added != 0)                                               
   21e44:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   21e48:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   21e4c:	0a00000d 	beq	21e88 <fat_file_extend+0x1bc>                 <== NOT EXECUTED
    {                                                                 
        fat_fd->map.last_cln = last_cl;                               
        if (fat_fd->fat_file_type == FAT_DIRECTORY)                   
   21e50:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   21e54:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* update number of the last cluster of the file if it changed */ 
    if (cls_added != 0)                                               
    {                                                                 
        fat_fd->map.last_cln = last_cl;                               
   21e58:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   21e5c:	e584303c 	str	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
        if (fat_fd->fat_file_type == FAT_DIRECTORY)                   
   21e60:	1a000008 	bne	21e88 <fat_file_extend+0x1bc>                 <== NOT EXECUTED
        {                                                             
            rc = fat_init_clusters_chain(mt_entry, chain);            
   21e64:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   21e68:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   21e6c:	eb000363 	bl	22c00 <fat_init_clusters_chain>                <== NOT EXECUTED
            if ( rc != RC_OK )                                        
   21e70:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   21e74:	0a000003 	beq	21e88 <fat_file_extend+0x1bc>                 <== NOT EXECUTED
            {                                                         
                fat_free_fat_clusters_chain(mt_entry, chain);         
   21e78:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   21e7c:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   21e80:	eb005d7e 	bl	39480 <fat_free_fat_clusters_chain>            <== NOT EXECUTED
                return rc;                                            
   21e84:	ea000001 	b	21e90 <fat_file_extend+0x1c4>                   <== NOT EXECUTED
            }                                                         
        }                                                             
    }                                                                 
                                                                      
    fat_fd->fat_file_size = new_length;                               
   21e88:	e5847018 	str	r7, [r4, #24]                                 <== NOT EXECUTED
                                                                      
    return RC_OK;                                                     
   21e8c:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
}                                                                     
   21e90:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   21e94:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
   21e98:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00021b1c <fat_file_ioctl>: fat_file_ioctl( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd, int cmd, ...) {
   21b1c:	e92d000c 	push	{r2, r3}                                     <== NOT EXECUTED
   21b20:	e92d4033 	push	{r0, r1, r4, r5, lr}                         <== NOT EXECUTED
   21b24:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
                                                                      
    switch (cmd)                                                      
   21b28:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
    int                                   cmd,                        
    ...)                                                              
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = 0;                                       
   21b2c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   21b30:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
    uint32_t       cl_start = 0;                                      
    uint32_t       pos = 0;                                           
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
   21b34:	e28d3018 	add	r3, sp, #24                                   <== NOT EXECUTED
   21b38:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    fat_file_fd_t                        *fat_fd,                     
    int                                   cmd,                        
    ...)                                                              
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   21b3c:	e590c034 	ldr	ip, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
                                                                      
    switch (cmd)                                                      
   21b40:	1a00001c 	bne	21bb8 <fat_file_ioctl+0x9c>                   <== NOT EXECUTED
        case F_CLU_NUM:                                               
            pos = va_arg(ap, uint32_t  );                             
            ret = va_arg(ap, uint32_t   *);                           
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size )                       
   21b44:	e5913018 	ldr	r3, [r1, #24]                                 <== NOT EXECUTED
    va_start(ap, cmd);                                                
                                                                      
    switch (cmd)                                                      
    {                                                                 
        case F_CLU_NUM:                                               
            pos = va_arg(ap, uint32_t  );                             
   21b48:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
            ret = va_arg(ap, uint32_t   *);                           
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size )                       
   21b4c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
                                                                      
    switch (cmd)                                                      
    {                                                                 
        case F_CLU_NUM:                                               
            pos = va_arg(ap, uint32_t  );                             
            ret = va_arg(ap, uint32_t   *);                           
   21b50:	e28d3020 	add	r3, sp, #32                                   <== NOT EXECUTED
   21b54:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
   21b58:	e59d401c 	ldr	r4, [sp, #28]                                 <== NOT EXECUTED
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size )                       
   21b5c:	3a000002 	bcc	21b6c <fat_file_ioctl+0x50>                   <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EIO );          
   21b60:	eb006ce6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   21b64:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   21b68:	ea000014 	b	21bc0 <fat_file_ioctl+0xa4>                     <== NOT EXECUTED
                                                                      
            if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                       
   21b6c:	e5913020 	ldr	r3, [r1, #32]                                 <== NOT EXECUTED
   21b70:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   21b74:	1a000007 	bne	21b98 <fat_file_ioctl+0x7c>                   <== NOT EXECUTED
   21b78:	e5913024 	ldr	r3, [r1, #36]	; 0x24                          <== NOT EXECUTED
   21b7c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   21b80:	1a000004 	bne	21b98 <fat_file_ioctl+0x7c>                   <== NOT EXECUTED
                (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))        
   21b84:	e5dc500a 	ldrb	r5, [ip, #10]                                <== NOT EXECUTED
   21b88:	e3150003 	tst	r5, #3                                        <== NOT EXECUTED
            {                                                         
                /* cluster 0 (zero) reserved for root dir */          
                *ret  = 0;                                            
   21b8c:	15843000 	strne	r3, [r4]                                    <== NOT EXECUTED
   21b90:	11a00003 	movne	r0, r3                                      <== NOT EXECUTED
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size )                       
                rtems_set_errno_and_return_minus_one( EIO );          
                                                                      
            if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                       
                (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))        
   21b94:	1a00000b 	bne	21bc8 <fat_file_ioctl+0xac>                   <== NOT EXECUTED
                return RC_OK;                                         
            }                                                         
                                                                      
            cl_start = pos >> fs_info->vol.bpc_log2;                  
                                                                      
            rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
   21b98:	e5dc3008 	ldrb	r3, [ip, #8]                                 <== NOT EXECUTED
   21b9c:	e1a02332 	lsr	r2, r2, r3                                    <== NOT EXECUTED
   21ba0:	e28d3004 	add	r3, sp, #4                                    <== NOT EXECUTED
   21ba4:	ebffff64 	bl	2193c <fat_file_lseek>                         <== NOT EXECUTED
            if ( rc != RC_OK )                                        
   21ba8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                return rc;                                            
                                                                      
            *ret = cur_cln;                                           
   21bac:	059d3004 	ldreq	r3, [sp, #4]                                <== NOT EXECUTED
   21bb0:	05843000 	streq	r3, [r4]                                    <== NOT EXECUTED
   21bb4:	ea000003 	b	21bc8 <fat_file_ioctl+0xac>                     <== NOT EXECUTED
            break;                                                    
                                                                      
        default:                                                      
            errno = EINVAL;                                           
   21bb8:	eb006cd0 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   21bbc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   21bc0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   21bc4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
            rc = -1;                                                  
            break;                                                    
    }                                                                 
    return rc;                                                        
}                                                                     
   21bc8:	e8bd403c 	pop	{r2, r3, r4, r5, lr}                          <== NOT EXECUTED
   21bcc:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
   21bd0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0002193c <fat_file_lseek>: rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd, uint32_t file_cln, uint32_t *disk_cln ) {
   2193c:	e92d47f1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, lr}         <== NOT EXECUTED
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
   21940:	e5918034 	ldr	r8, [r1, #52]	; 0x34                          <== NOT EXECUTED
   21944:	e1520008 	cmp	r2, r8                                        <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t  *mt_entry,                  
    fat_file_fd_t                         *fat_fd,                    
    uint32_t                               file_cln,                  
    uint32_t                              *disk_cln                   
    )                                                                 
{                                                                     
   21948:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
   2194c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   21950:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   21954:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
        *disk_cln = fat_fd->map.disk_cln;                             
   21958:	05913038 	ldreq	r3, [r1, #56]	; 0x38                        <== NOT EXECUTED
    uint32_t                              *disk_cln                   
    )                                                                 
{                                                                     
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
   2195c:	0a000015 	beq	219b8 <fat_file_lseek+0x7c>                   <== NOT EXECUTED
        uint32_t   count;                                             
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
        {                                                             
            cur_cln = fat_fd->map.disk_cln;                           
   21960:	85913038 	ldrhi	r3, [r1, #56]	; 0x38                        <== NOT EXECUTED
            count = file_cln - fat_fd->map.file_cln;                  
        }                                                             
        else                                                          
        {                                                             
            cur_cln = fat_fd->cln;                                    
   21964:	9591301c 	ldrls	r3, [r1, #28]                               <== NOT EXECUTED
        uint32_t   count;                                             
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
        {                                                             
            cur_cln = fat_fd->map.disk_cln;                           
   21968:	858d3000 	strhi	r3, [sp]                                    <== NOT EXECUTED
            count = file_cln - fat_fd->map.file_cln;                  
   2196c:	80688002 	rsbhi	r8, r8, r2                                  <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
            cur_cln = fat_fd->cln;                                    
   21970:	958d3000 	strls	r3, [sp]                                    <== NOT EXECUTED
   21974:	91a08002 	movls	r8, r2                                      <== NOT EXECUTED
   21978:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
        {                                                             
            rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);    
   2197c:	e1a0a00d 	mov	sl, sp                                        <== NOT EXECUTED
            cur_cln = fat_fd->cln;                                    
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
   21980:	ea000005 	b	2199c <fat_file_lseek+0x60>                     <== NOT EXECUTED
        {                                                             
            rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);    
   21984:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
   21988:	eb005e62 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
            if ( rc != RC_OK )                                        
   2198c:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
                return rc;                                            
   21990:	11a04fc3 	asrne	r4, r3, #31                                 <== NOT EXECUTED
   21994:	1a00000a 	bne	219c4 <fat_file_lseek+0x88>                   <== NOT EXECUTED
            cur_cln = fat_fd->cln;                                    
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
   21998:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   2199c:	e1560008 	cmp	r6, r8                                        <== NOT EXECUTED
        {                                                             
            rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);    
   219a0:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   219a4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
            cur_cln = fat_fd->cln;                                    
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
   219a8:	3afffff5 	bcc	21984 <fat_file_lseek+0x48>                   <== NOT EXECUTED
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
        fat_fd->map.disk_cln = cur_cln;                               
   219ac:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
            if ( rc != RC_OK )                                        
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
   219b0:	e5845034 	str	r5, [r4, #52]	; 0x34                          <== NOT EXECUTED
        fat_fd->map.disk_cln = cur_cln;                               
   219b4:	e5843038 	str	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
        *disk_cln = cur_cln;                                          
   219b8:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
   219bc:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   219c0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    }                                                                 
    return RC_OK;                                                     
}                                                                     
   219c4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   219c8:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   219cc:	e8bd87f8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, pc}          <== NOT EXECUTED
                                                                      

00021ad0 <fat_file_mark_removed>: static inline uint32_t fat_construct_key( rtems_filesystem_mount_table_entry_t *mt_entry, fat_pos_t *pos) { return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
   21ad0:	e5913020 	ldr	r3, [r1, #32]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
   21ad4:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
void                                                                  
fat_file_mark_removed(                                                
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   21ad8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   21adc:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   21ae0:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
   21ae4:	e5946024 	ldr	r6, [r4, #36]	; 0x24                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
   21ae8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   21aec:	ebffaa53 	bl	c440 <_Chain_Extract>                          <== 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 );                               
   21af0:	e1a062a6 	lsr	r6, r6, #5                                    <== NOT EXECUTED
   21af4:	e5953068 	ldr	r3, [r5, #104]	; 0x68                         <== NOT EXECUTED
   21af8:	e2066001 	and	r6, r6, #1                                    <== NOT EXECUTED
   21afc:	e3a0000c 	mov	r0, #12                                       <== NOT EXECUTED
   21b00:	e0203096 	mla	r0, r6, r0, r3                                <== NOT EXECUTED
   21b04:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   21b08:	ebffaa41 	bl	c414 <_Chain_Append>                           <== NOT EXECUTED
                                                                      
    _hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);           
                                                                      
    _hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);           
                                                                      
    fat_fd->flags |= FAT_FILE_REMOVED;                                
   21b0c:	e5d43030 	ldrb	r3, [r4, #48]	; 0x30                         <== NOT EXECUTED
   21b10:	e3833001 	orr	r3, r3, #1                                    <== NOT EXECUTED
   21b14:	e5c43030 	strb	r3, [r4, #48]	; 0x30                         <== NOT EXECUTED
}                                                                     
   21b18:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

0002235c <fat_file_open>: fat_file_open( rtems_filesystem_mount_table_entry_t *mt_entry, fat_dir_pos_t *dir_pos, fat_file_fd_t **fat_fd ) {
   2235c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
static inline uint32_t                                                
fat_construct_key(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) + 
   22360:	e5916000 	ldr	r6, [r1]                                      <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
   22364:	e3560001 	cmp	r6, #1                                        <== NOT EXECUTED
   22368:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
   2236c:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
   22370:	e1a0a002 	mov	sl, r2                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   22374:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
   22378:	0a00000b 	beq	223ac <fat_file_open+0x50>                    <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   2237c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   22380:	1a000003 	bne	22394 <fat_file_open+0x38>                    <== NOT EXECUTED
   22384:	e5d4300a 	ldrb	r3, [r4, #10]                                <== NOT EXECUTED
   22388:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   2238c:	1594601c 	ldrne	r6, [r4, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22390:	1a000003 	bne	223a4 <fat_file_open+0x48>                    <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22394:	e5d42005 	ldrb	r2, [r4, #5]                                 <== NOT EXECUTED
   22398:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
   2239c:	e2466002 	sub	r6, r6, #2                                    <== NOT EXECUTED
   223a0:	e0836216 	add	r6, r3, r6, lsl r2                            <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(mt_entry, cln) <<           
   223a4:	e5d43003 	ldrb	r3, [r4, #3]                                 <== NOT EXECUTED
   223a8:	e1a06316 	lsl	r6, r6, r3                                    <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
   223ac:	e5983004 	ldr	r3, [r8, #4]                                  <== NOT EXECUTED
static inline uint32_t                                                
fat_construct_key(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) + 
   223b0:	e1a022a3 	lsr	r2, r3, #5                                    <== NOT EXECUTED
   223b4:	e08664a3 	add	r6, r6, r3, lsr #9                            <== NOT EXECUTED
   223b8:	e202200f 	and	r2, r2, #15                                   <== NOT EXECUTED
   223bc:	e0826206 	add	r6, r2, r6, lsl #4                            <== NOT EXECUTED
    uint32_t                               key2,                      
    fat_file_fd_t                          **ret                      
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
   223c0:	e2063001 	and	r3, r6, #1                                    <== NOT EXECUTED
   223c4:	e3a0200c 	mov	r2, #12                                       <== NOT EXECUTED
   223c8:	e0070392 	mul	r7, r2, r3                                    <== NOT EXECUTED
   223cc:	e5943064 	ldr	r3, [r4, #100]	; 0x64                         <== NOT EXECUTED
   223d0:	e0830007 	add	r0, r3, r7                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
   223d4:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
   223d8:	e7933007 	ldr	r3, [r3, r7]                                  <== NOT EXECUTED
   223dc:	ea00001c 	b	22454 <fat_file_open+0xf8>                      <== NOT EXECUTED
   223e0:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
   223e4:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   223e8:	e242c002 	sub	ip, r2, #2                                    <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
   223ec:	0a00000a 	beq	2241c <fat_file_open+0xc0>                    <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   223f0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   223f4:	1a000003 	bne	22408 <fat_file_open+0xac>                    <== NOT EXECUTED
   223f8:	e5d4200a 	ldrb	r2, [r4, #10]                                <== NOT EXECUTED
   223fc:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   22400:	1594201c 	ldrne	r2, [r4, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22404:	1a000002 	bne	22414 <fat_file_open+0xb8>                    <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22408:	e5d42005 	ldrb	r2, [r4, #5]                                 <== NOT EXECUTED
   2240c:	e5941030 	ldr	r1, [r4, #48]	; 0x30                          <== NOT EXECUTED
   22410:	e081221c 	add	r2, r1, ip, lsl r2                            <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(mt_entry, cln) <<           
   22414:	e5d41003 	ldrb	r1, [r4, #3]                                 <== NOT EXECUTED
   22418:	e1a02112 	lsl	r2, r2, r1                                    <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
   2241c:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
    {                                                                 
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(mt_entry, &ffd->dir_pos.sname);
                                                                      
        if ( (key1) == ck)                                            
   22420:	e1a0c2a1 	lsr	ip, r1, #5                                    <== NOT EXECUTED
   22424:	e20cc00f 	and	ip, ip, #15                                   <== NOT EXECUTED
   22428:	e08224a1 	add	r2, r2, r1, lsr #9                            <== NOT EXECUTED
   2242c:	e08c2202 	add	r2, ip, r2, lsl #4                            <== NOT EXECUTED
   22430:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
   22434:	1a000005 	bne	22450 <fat_file_open+0xf4>                    <== NOT EXECUTED
    rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);    
    if ( rc == RC_OK )                                                
    {                                                                 
        /* return pointer to fat_file_descriptor allocated before */  
        (*fat_fd) = lfat_fd;                                          
        lfat_fd->links_num++;                                         
   22438:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
   2243c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   22440:	e5832008 	str	r2, [r3, #8]                                  <== NOT EXECUTED
    /* access "valid" hash table */                                   
    rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);    
    if ( rc == RC_OK )                                                
    {                                                                 
        /* return pointer to fat_file_descriptor allocated before */  
        (*fat_fd) = lfat_fd;                                          
   22444:	e58a3000 	str	r3, [sl]                                      <== NOT EXECUTED
        lfat_fd->links_num++;                                         
   22448:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
        return rc;                                                    
   2244c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
   22450:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
   22454:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
   22458:	1affffe0 	bne	223e0 <fat_file_open+0x84>                    <== NOT EXECUTED
   2245c:	ea00004d 	b	22598 <fat_file_open+0x23c>                     <== NOT EXECUTED
static inline uint32_t                                                
fat_construct_key(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_pos_t                            *pos)                        
{                                                                     
    return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) + 
   22460:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
   22464:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
   22468:	0a00000b 	beq	2249c <fat_file_open+0x140>                   <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   2246c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   22470:	1a000003 	bne	22484 <fat_file_open+0x128>                   <== NOT EXECUTED
   22474:	e5d4100a 	ldrb	r1, [r4, #10]                                <== NOT EXECUTED
   22478:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   2247c:	1594201c 	ldrne	r2, [r4, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22480:	1a000003 	bne	22494 <fat_file_open+0x138>                   <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22484:	e5d4c005 	ldrb	ip, [r4, #5]                                 <== NOT EXECUTED
   22488:	e5941030 	ldr	r1, [r4, #48]	; 0x30                          <== NOT EXECUTED
   2248c:	e2422002 	sub	r2, r2, #2                                    <== NOT EXECUTED
   22490:	e0812c12 	add	r2, r1, r2, lsl ip                            <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(mt_entry, cln) <<           
   22494:	e5d41003 	ldrb	r1, [r4, #3]                                 <== NOT EXECUTED
   22498:	e1a02112 	lsl	r2, r2, r1                                    <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
   2249c:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
    {                                                                 
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(mt_entry, &ffd->dir_pos.sname);
                                                                      
        if ( (key1) == ck)                                            
   224a0:	e1a0c2a1 	lsr	ip, r1, #5                                    <== NOT EXECUTED
   224a4:	e08224a1 	add	r2, r2, r1, lsr #9                            <== NOT EXECUTED
   224a8:	e20cc00f 	and	ip, ip, #15                                   <== NOT EXECUTED
   224ac:	e08c2202 	add	r2, ip, r2, lsl #4                            <== NOT EXECUTED
   224b0:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
   224b4:	1a000004 	bne	224cc <fat_file_open+0x170>                   <== NOT EXECUTED
        {                                                             
            if ( ((key2) == 0) || ((key2) == ffd->ino) )              
   224b8:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   224bc:	0a000007 	beq	224e0 <fat_file_open+0x184>                   <== NOT EXECUTED
   224c0:	e593200c 	ldr	r2, [r3, #12]                                 <== NOT EXECUTED
   224c4:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
   224c8:	0a000004 	beq	224e0 <fat_file_open+0x184>                   <== NOT EXECUTED
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
   224cc:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
   224d0:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
   224d4:	1affffe1 	bne	22460 <fat_file_open+0x104>                   <== NOT EXECUTED
   224d8:	e3e09000 	mvn	r9, #0                                        <== NOT EXECUTED
   224dc:	ea000000 	b	224e4 <fat_file_open+0x188>                     <== NOT EXECUTED
   224e0:	e3a09000 	mov	r9, #0                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* access "removed-but-still-open" hash table */                  
    rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);  
                                                                      
    lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
   224e4:	e3a00044 	mov	r0, #68	; 0x44                                <== NOT EXECUTED
   224e8:	ebff9618 	bl	7d50 <malloc>                                  <== NOT EXECUTED
    if ( lfat_fd == NULL )                                            
   224ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* access "removed-but-still-open" hash table */                  
    rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);  
                                                                      
    lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
   224f0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   224f4:	e58a0000 	str	r0, [sl]                                      <== NOT EXECUTED
    if ( lfat_fd == NULL )                                            
   224f8:	1a000004 	bne	22510 <fat_file_open+0x1b4>                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
   224fc:	eb006a7f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22500:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   22504:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   22508:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   2250c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
   22510:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   22514:	e3a02044 	mov	r2, #68	; 0x44                                <== NOT EXECUTED
   22518:	eb0077af 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    lfat_fd->links_num = 1;                                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
   2251c:	e5d5c030 	ldrb	ip, [r5, #48]	; 0x30                         <== NOT EXECUTED
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
   22520:	e898000f 	ldm	r8, {r0, r1, r2, r3}                          <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
                                                                      
    lfat_fd->links_num = 1;                                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
   22524:	e3cce001 	bic	lr, ip, #1                                    <== NOT EXECUTED
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
   22528:	e285c020 	add	ip, r5, #32                                   <== NOT EXECUTED
                                                                      
    if ( rc != RC_OK )                                                
   2252c:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
                                                                      
    lfat_fd->links_num = 1;                                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
   22530:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
   22534:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          <== NOT EXECUTED
    if ( lfat_fd == NULL )                                            
        rtems_set_errno_and_return_minus_one( ENOMEM );               
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
                                                                      
    lfat_fd->links_num = 1;                                           
   22538:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   2253c:	e5853008 	str	r3, [r5, #8]                                  <== NOT EXECUTED
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
   22540:	e5c5e030 	strb	lr, [r5, #48]	; 0x30                         <== NOT EXECUTED
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
   22544:	e585803c 	str	r8, [r5, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
                                                                      
    if ( rc != RC_OK )                                                
        lfat_fd->ino = key;                                           
   22548:	1585600c 	strne	r6, [r5, #12]                               <== NOT EXECUTED
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
                                                                      
    if ( rc != RC_OK )                                                
   2254c:	1a00000b 	bne	22580 <fat_file_open+0x224>                   <== NOT EXECUTED
        lfat_fd->ino = key;                                           
    else                                                              
    {                                                                 
        lfat_fd->ino = fat_get_unique_ino(mt_entry);                  
   22550:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   22554:	eb000024 	bl	225ec <fat_get_unique_ino>                     <== NOT EXECUTED
                                                                      
        if ( lfat_fd->ino == 0 )                                      
   22558:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
    if ( rc != RC_OK )                                                
        lfat_fd->ino = key;                                           
    else                                                              
    {                                                                 
        lfat_fd->ino = fat_get_unique_ino(mt_entry);                  
   2255c:	e585000c 	str	r0, [r5, #12]                                 <== NOT EXECUTED
                                                                      
        if ( lfat_fd->ino == 0 )                                      
   22560:	1a000006 	bne	22580 <fat_file_open+0x224>                   <== NOT EXECUTED
        {                                                             
            free((*fat_fd));                                          
   22564:	e59a0000 	ldr	r0, [sl]                                      <== NOT EXECUTED
   22568:	ebff9451 	bl	76b4 <free>                                    <== NOT EXECUTED
            /*                                                        
             * XXX: kernel resource is unsufficient, but not the memory,
             * but there is no suitable errno :(                      
             */                                                       
            rtems_set_errno_and_return_minus_one( ENOMEM );           
   2256c:	eb006a63 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22570:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   22574:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   22578:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   2257c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== 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 );                               
   22580:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
   22584:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   22588:	e0800007 	add	r0, r0, r7                                    <== NOT EXECUTED
   2258c:	ebffa7a0 	bl	c414 <_Chain_Append>                           <== NOT EXECUTED
   22590:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
     * other fields of fat-file descriptor will be initialized on upper
     * level                                                          
     */                                                               
                                                                      
    return RC_OK;                                                     
}                                                                     
   22594:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    uint32_t                               key2,                      
    fat_file_fd_t                          **ret                      
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
    rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
   22598:	e5943068 	ldr	r3, [r4, #104]	; 0x68                         <== NOT EXECUTED
   2259c:	e0830007 	add	r0, r3, r7                                    <== NOT EXECUTED
   225a0:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
   225a4:	e7933007 	ldr	r3, [r3, r7]                                  <== NOT EXECUTED
   225a8:	eaffffc8 	b	224d0 <fat_file_open+0x174>                     <== NOT EXECUTED
                                                                      

000220d0 <fat_file_read>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, uint8_t *buf ) {
   220d0:	e92d4fff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
    uint32_t       sec = 0;                                           
    uint32_t       byte = 0;                                          
    uint32_t       c = 0;                                             
                                                                      
    /* it couldn't be removed - otherwise cache update will be broken */
    if (count == 0)                                                   
   220d4:	e2535000 	subs	r5, r3, #0                                   <== NOT EXECUTED
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    uint8_t                              *buf                         
)                                                                     
{                                                                     
   220d8:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
   220dc:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   220e0:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    ssize_t        ret = 0;                                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   220e4:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t       sec = 0;                                           
    uint32_t       byte = 0;                                          
    uint32_t       c = 0;                                             
                                                                      
    /* it couldn't be removed - otherwise cache update will be broken */
    if (count == 0)                                                   
   220e8:	0a00006d 	beq	222a4 <fat_file_read+0x1d4>                   <== NOT EXECUTED
                                                                      
    /*                                                                
     * >= because start is offset and computed from 0 and file_size   
     * computed from 1                                                
     */                                                               
    if ( start >= fat_fd->fat_file_size )                             
   220ec:	e5913018 	ldr	r3, [r1, #24]                                 <== NOT EXECUTED
   220f0:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   220f4:	2a00006a 	bcs	222a4 <fat_file_read+0x1d4>                   <== NOT EXECUTED
        return FAT_EOF;                                               
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
   220f8:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   220fc:	8a000002 	bhi	2210c <fat_file_read+0x3c>                    <== NOT EXECUTED
   22100:	e0652003 	rsb	r2, r5, r3                                    <== NOT EXECUTED
   22104:	e1570002 	cmp	r7, r2                                        <== NOT EXECUTED
   22108:	9a000000 	bls	22110 <fat_file_read+0x40>                    <== NOT EXECUTED
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
   2210c:	e0675003 	rsb	r5, r7, r3                                    <== NOT EXECUTED
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
   22110:	e5963020 	ldr	r3, [r6, #32]                                 <== NOT EXECUTED
   22114:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
{                                                                     
    int            rc = RC_OK;                                        
    ssize_t        ret = 0;                                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
   22118:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   2211c:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
   22120:	1a000019 	bne	2218c <fat_file_read+0xbc>                    <== NOT EXECUTED
   22124:	e5963024 	ldr	r3, [r6, #36]	; 0x24                          <== NOT EXECUTED
   22128:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   2212c:	1a000016 	bne	2218c <fat_file_read+0xbc>                    <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
   22130:	e5d4300a 	ldrb	r3, [r4, #10]                                <== NOT EXECUTED
   22134:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
   22138:	0a000013 	beq	2218c <fat_file_read+0xbc>                    <== NOT EXECUTED
    {                                                                 
        sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);   
   2213c:	e596201c 	ldr	r2, [r6, #28]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22140:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22144:	15d40005 	ldrbne	r0, [r4, #5]                               <== NOT EXECUTED
   22148:	15941030 	ldrne	r1, [r4, #48]	; 0x30                        <== NOT EXECUTED
   2214c:	12423002 	subne	r3, r2, #2                                  <== NOT EXECUTED
   22150:	10813013 	addne	r3, r1, r3, lsl r0                          <== NOT EXECUTED
        sec += (start >> fs_info->vol.sec_log2);                      
        byte = start & (fs_info->vol.bps - 1);                        
                                                                      
        ret = _fat_block_read(mt_entry, sec, byte, count, buf);       
   22154:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        return fs_info->vol.rdir_loc;                                 
   22158:	0594301c 	ldreq	r3, [r4, #28]                               <== NOT EXECUTED
   2215c:	e5d41002 	ldrb	r1, [r4, #2]                                 <== NOT EXECUTED
   22160:	e59dc034 	ldr	ip, [sp, #52]	; 0x34                          <== NOT EXECUTED
   22164:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   22168:	e0831137 	add	r1, r3, r7, lsr r1                            <== NOT EXECUTED
   2216c:	e0072002 	and	r2, r7, r2                                    <== NOT EXECUTED
   22170:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   22174:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   22178:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   2217c:	eb0002c9 	bl	22ca8 <_fat_block_read>                        <== NOT EXECUTED
        if ( ret < 0 )                                                
   22180:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22184:	aa000049 	bge	222b0 <fat_file_read+0x1e0>                   <== NOT EXECUTED
   22188:	ea000047 	b	222ac <fat_file_read+0x1dc>                     <== NOT EXECUTED
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
   2218c:	e5d43008 	ldrb	r3, [r4, #8]                                 <== NOT EXECUTED
   22190:	e1a03337 	lsr	r3, r7, r3                                    <== NOT EXECUTED
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   22194:	e28db00c 	add	fp, sp, #12                                   <== NOT EXECUTED
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
   22198:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   2219c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
   221a0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   221a4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   221a8:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
   221ac:	e1d4a0b6 	ldrh	sl, [r4, #6]                                 <== NOT EXECUTED
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   221b0:	ebfffde1 	bl	2193c <fat_file_lseek>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   221b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   221b8:	1a00003c 	bne	222b0 <fat_file_read+0x1e0>                   <== NOT EXECUTED
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
   221bc:	e24aa001 	sub	sl, sl, #1                                    <== NOT EXECUTED
   221c0:	e007a00a 	and	sl, r7, sl                                    <== NOT EXECUTED
   221c4:	e58da004 	str	sl, [sp, #4]                                  <== NOT EXECUTED
   221c8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   221cc:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
   221d0:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
   221d4:	ea000026 	b	22274 <fat_file_read+0x1a4>                     <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
   221d8:	e1d4c0b6 	ldrh	ip, [r4, #6]                                 <== NOT EXECUTED
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
   221dc:	e59d700c 	ldr	r7, [sp, #12]                                 <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
   221e0:	e061c00c 	rsb	ip, r1, ip                                    <== NOT EXECUTED
   221e4:	e15c0005 	cmp	ip, r5                                        <== NOT EXECUTED
   221e8:	21a0c005 	movcs	ip, r5                                      <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   221ec:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   221f0:	e5983034 	ldr	r3, [r8, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   221f4:	e2477002 	sub	r7, r7, #2                                    <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   221f8:	1a000003 	bne	2220c <fat_file_read+0x13c>                   <== NOT EXECUTED
   221fc:	e5d3200a 	ldrb	r2, [r3, #10]                                <== NOT EXECUTED
   22200:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   22204:	1593701c 	ldrne	r7, [r3, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22208:	1a000002 	bne	22218 <fat_file_read+0x148>                   <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   2220c:	e5932030 	ldr	r2, [r3, #48]	; 0x30                          <== NOT EXECUTED
   22210:	e5d33005 	ldrb	r3, [r3, #5]                                 <== NOT EXECUTED
   22214:	e0827317 	add	r7, r2, r7, lsl r3                            <== NOT EXECUTED
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);  
   22218:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
   2221c:	e5d49002 	ldrb	r9, [r4, #2]                                 <== NOT EXECUTED
   22220:	e59d3034 	ldr	r3, [sp, #52]	; 0x34                          <== NOT EXECUTED
   22224:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   22228:	e083e00a 	add	lr, r3, sl                                    <== NOT EXECUTED
   2222c:	e0012002 	and	r2, r1, r2                                    <== NOT EXECUTED
   22230:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
   22234:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   22238:	e0871931 	add	r1, r7, r1, lsr r9                            <== NOT EXECUTED
   2223c:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
   22240:	e08aa00c 	add	sl, sl, ip                                    <== NOT EXECUTED
                                                                      
        ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);  
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
   22244:	e06c5005 	rsb	r5, ip, r5                                    <== NOT EXECUTED
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);  
   22248:	eb000296 	bl	22ca8 <_fat_block_read>                        <== NOT EXECUTED
        if ( ret < 0 )                                                
   2224c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   22250:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   22254:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);  
        if ( ret < 0 )                                                
   22258:	ba000013 	blt	222ac <fat_file_read+0x1dc>                   <== NOT EXECUTED
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
   2225c:	e59d900c 	ldr	r9, [sp, #12]                                 <== NOT EXECUTED
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   22260:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   22264:	eb005c2b 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   22268:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   2226c:	1a00000f 	bne	222b0 <fat_file_read+0x1e0>                   <== NOT EXECUTED
        ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);  
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
   22270:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
   22274:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   22278:	1affffd6 	bne	221d8 <fat_file_read+0x108>                   <== NOT EXECUTED
        ofs = 0;                                                      
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
   2227c:	e59dc004 	ldr	ip, [sp, #4]                                  <== NOT EXECUTED
   22280:	e5d43008 	ldrb	r3, [r4, #8]                                 <== NOT EXECUTED
   22284:	e24c7001 	sub	r7, ip, #1                                    <== NOT EXECUTED
   22288:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   2228c:	e087700a 	add	r7, r7, sl                                    <== NOT EXECUTED
   22290:	e0827337 	add	r7, r2, r7, lsr r3                            <== NOT EXECUTED
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
    fat_fd->map.disk_cln = save_cln;                                  
   22294:	e5869038 	str	r9, [r6, #56]	; 0x38                          <== NOT EXECUTED
        ofs = 0;                                                      
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
   22298:	e5867034 	str	r7, [r6, #52]	; 0x34                          <== NOT EXECUTED
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
    fat_fd->map.disk_cln = save_cln;                                  
                                                                      
    return cmpltd;                                                    
   2229c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   222a0:	ea000002 	b	222b0 <fat_file_read+0x1e0>                     <== NOT EXECUTED
   222a4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   222a8:	ea000000 	b	222b0 <fat_file_read+0x1e0>                     <== NOT EXECUTED
   222ac:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
   222b0:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   222b4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00021884 <fat_file_reopen>: * RC_OK */ int fat_file_reopen(fat_file_fd_t *fat_fd) { fat_fd->links_num++;
   21884:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
   21888:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   2188c:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   21890:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   21894:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00021898 <fat_file_size>: fat_fs_info_t *fs_info = mt_entry->fs_info; uint32_t cur_cln = fat_fd->cln; uint32_t save_cln = 0; /* Have we requested root dir size for FAT12/16? */ if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
   21898:	e5913020 	ldr	r3, [r1, #32]                                 <== NOT EXECUTED
   2189c:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
int                                                                   
fat_file_size(                                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   218a0:	e92d45f1 	push	{r0, r4, r5, r6, r7, r8, sl, lr}             <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = fat_fd->cln;                             
   218a4:	e591301c 	ldr	r3, [r1, #28]                                 <== NOT EXECUTED
int                                                                   
fat_file_size(                                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   218a8:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   218ac:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   218b0:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t       cur_cln = fat_fd->cln;                             
    uint32_t       save_cln = 0;                                      
                                                                      
    /* Have we requested root dir size for FAT12/16? */               
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
   218b4:	1a000007 	bne	218d8 <fat_file_size+0x40>                    <== NOT EXECUTED
   218b8:	e5910024 	ldr	r0, [r1, #36]	; 0x24                          <== NOT EXECUTED
   218bc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   218c0:	1a000004 	bne	218d8 <fat_file_size+0x40>                    <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
   218c4:	e5d5200a 	ldrb	r2, [r5, #10]                                <== NOT EXECUTED
   218c8:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
    {                                                                 
        fat_fd->fat_file_size = fs_info->vol.rdir_size;               
   218cc:	15953028 	ldrne	r3, [r5, #40]	; 0x28                        <== NOT EXECUTED
   218d0:	15813018 	strne	r3, [r1, #24]                               <== NOT EXECUTED
    uint32_t       cur_cln = fat_fd->cln;                             
    uint32_t       save_cln = 0;                                      
                                                                      
    /* Have we requested root dir size for FAT12/16? */               
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
   218d4:	1a000017 	bne	21938 <fat_file_size+0xa0>                    <== NOT EXECUTED
    {                                                                 
        fat_fd->fat_file_size = fs_info->vol.rdir_size;               
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
   218d8:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = fat_fd->cln;                             
   218dc:	e28d6004 	add	r6, sp, #4                                    <== NOT EXECUTED
   218e0:	e5263004 	str	r3, [r6, #-4]!                                <== NOT EXECUTED
    {                                                                 
        fat_fd->fat_file_size = fs_info->vol.rdir_size;               
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
   218e4:	e584c018 	str	ip, [r4, #24]                                 <== NOT EXECUTED
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   218e8:	ea000007 	b	2190c <fat_file_size+0x74>                      <== NOT EXECUTED
    {                                                                 
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   218ec:	eb005e89 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   218f0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   218f4:	1a00000f 	bne	21938 <fat_file_size+0xa0>                    <== NOT EXECUTED
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
   218f8:	e5942018 	ldr	r2, [r4, #24]                                 <== NOT EXECUTED
   218fc:	e1d530b6 	ldrh	r3, [r5, #6]                                 <== NOT EXECUTED
   21900:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
   21904:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
   21908:	e1a0c007 	mov	ip, r7                                        <== NOT EXECUTED
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   2190c:	e59d7000 	ldr	r7, [sp]                                      <== NOT EXECUTED
   21910:	e285300c 	add	r3, r5, #12                                   <== NOT EXECUTED
   21914:	e8930408 	ldm	r3, {r3, sl}                                  <== NOT EXECUTED
   21918:	e0073003 	and	r3, r7, r3                                    <== NOT EXECUTED
   2191c:	e153000a 	cmp	r3, sl                                        <== NOT EXECUTED
    {                                                                 
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   21920:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   21924:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   21928:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   2192c:	3affffee 	bcc	218ec <fat_file_size+0x54>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
    }                                                                 
    fat_fd->map.last_cln = save_cln;                                  
   21930:	e584c03c 	str	ip, [r4, #60]	; 0x3c                          <== NOT EXECUTED
   21934:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   21938:	e8bd85f8 	pop	{r3, r4, r5, r6, r7, r8, sl, pc}              <== NOT EXECUTED
                                                                      

00021bd4 <fat_file_truncate>: uint32_t cur_cln = 0; uint32_t cl_start = 0; uint32_t new_last_cln = FAT_UNDEFINED_VALUE; if ( new_length >= fat_fd->fat_file_size )
   21bd4:	e5913018 	ldr	r3, [r1, #24]                                 <== NOT EXECUTED
   21bd8:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
fat_file_truncate(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              new_length                  
    )                                                                 
{                                                                     
   21bdc:	e92d4073 	push	{r0, r1, r4, r5, r6, lr}                     <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   21be0:	e590c034 	ldr	ip, [r0, #52]	; 0x34                          <== NOT EXECUTED
fat_file_truncate(                                                    
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              new_length                  
    )                                                                 
{                                                                     
   21be4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   21be8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    uint32_t       cur_cln = 0;                                       
    uint32_t       cl_start = 0;                                      
    uint32_t       new_last_cln = FAT_UNDEFINED_VALUE;                
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
   21bec:	2a000030 	bcs	21cb4 <fat_file_truncate+0xe0>                <== NOT EXECUTED
    uint32_t                              new_length                  
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = 0;                                       
   21bf0:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   21bf4:	e58d4004 	str	r4, [sp, #4]                                  <== NOT EXECUTED
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
        return rc;                                                    
                                                                      
    assert(fat_fd->fat_file_size);                                    
   21bf8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = 0;                                       
    uint32_t       cl_start = 0;                                      
    uint32_t       new_last_cln = FAT_UNDEFINED_VALUE;                
   21bfc:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   21c00:	e58d4000 	str	r4, [sp]                                      <== NOT EXECUTED
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
        return rc;                                                    
                                                                      
    assert(fat_fd->fat_file_size);                                    
   21c04:	059f00b0 	ldreq	r0, [pc, #176]	; 21cbc <fat_file_truncate+0xe8><== NOT EXECUTED
   21c08:	059f10b0 	ldreq	r1, [pc, #176]	; 21cc0 <fat_file_truncate+0xec><== NOT EXECUTED
   21c0c:	059f20b0 	ldreq	r2, [pc, #176]	; 21cc4 <fat_file_truncate+0xf0><== NOT EXECUTED
   21c10:	059f30b0 	ldreq	r3, [pc, #176]	; 21cc8 <fat_file_truncate+0xf4><== NOT EXECUTED
   21c14:	0b000c06 	bleq	24c34 <__assert_func>                        <== NOT EXECUTED
                                                                      
    cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
   21c18:	e1dc40b6 	ldrh	r4, [ip, #6]                                 <== NOT EXECUTED
   21c1c:	e5dcc008 	ldrb	ip, [ip, #8]                                 <== NOT EXECUTED
   21c20:	e2444001 	sub	r4, r4, #1                                    <== NOT EXECUTED
   21c24:	e0844002 	add	r4, r4, r2                                    <== NOT EXECUTED
   21c28:	e1a04c34 	lsr	r4, r4, ip                                    <== NOT EXECUTED
                                                                      
    if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size) 
   21c2c:	e1530c14 	cmp	r3, r4, lsl ip                                <== NOT EXECUTED
   21c30:	9a00001f 	bls	21cb4 <fat_file_truncate+0xe0>                <== NOT EXECUTED
        return RC_OK;                                                 
                                                                      
    if (cl_start != 0)                                                
   21c34:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   21c38:	0a000004 	beq	21c50 <fat_file_truncate+0x7c>                <== NOT EXECUTED
    {                                                                 
        rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
   21c3c:	e2442001 	sub	r2, r4, #1                                    <== NOT EXECUTED
   21c40:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   21c44:	ebffff3c 	bl	2193c <fat_file_lseek>                         <== NOT EXECUTED
        if (rc != RC_OK)                                              
   21c48:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21c4c:	1a000019 	bne	21cb8 <fat_file_truncate+0xe4>                <== NOT EXECUTED
            return rc;                                                
                                                                      
    }                                                                 
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   21c50:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   21c54:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   21c58:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   21c5c:	e28d3004 	add	r3, sp, #4                                    <== NOT EXECUTED
   21c60:	ebffff35 	bl	2193c <fat_file_lseek>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   21c64:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21c68:	1a000012 	bne	21cb8 <fat_file_truncate+0xe4>                <== NOT EXECUTED
        return rc;                                                    
                                                                      
    rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);              
   21c6c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   21c70:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   21c74:	eb005e01 	bl	39480 <fat_free_fat_clusters_chain>            <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   21c78:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21c7c:	1a00000d 	bne	21cb8 <fat_file_truncate+0xe4>                <== NOT EXECUTED
        return rc;                                                    
                                                                      
    if (cl_start != 0)                                                
   21c80:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   21c84:	0a00000b 	beq	21cb8 <fat_file_truncate+0xe4>                <== NOT EXECUTED
    {                                                                 
        rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
   21c88:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   21c8c:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
   21c90:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
   21c94:	eb005d07 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   21c98:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
        fat_fd->map.disk_cln = new_last_cln;                          
   21c9c:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    if (cl_start != 0)                                                
    {                                                                 
        rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
        if ( rc != RC_OK )                                            
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
   21ca0:	02444001 	subeq	r4, r4, #1                                  <== NOT EXECUTED
        fat_fd->map.disk_cln = new_last_cln;                          
        fat_fd->map.last_cln = new_last_cln;                          
   21ca4:	0585303c 	streq	r3, [r5, #60]	; 0x3c                        <== NOT EXECUTED
    if (cl_start != 0)                                                
    {                                                                 
        rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
        if ( rc != RC_OK )                                            
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
   21ca8:	05854034 	streq	r4, [r5, #52]	; 0x34                        <== NOT EXECUTED
        fat_fd->map.disk_cln = new_last_cln;                          
   21cac:	05853038 	streq	r3, [r5, #56]	; 0x38                        <== NOT EXECUTED
   21cb0:	ea000000 	b	21cb8 <fat_file_truncate+0xe4>                  <== NOT EXECUTED
        fat_fd->map.last_cln = new_last_cln;                          
   21cb4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    }                                                                 
    return RC_OK;                                                     
}                                                                     
   21cb8:	e8bd807c 	pop	{r2, r3, r4, r5, r6, pc}                      <== NOT EXECUTED
                                                                      

00021e9c <fat_file_write>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, const uint8_t *buf ) {
   21e9c:	e92d4fff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
    uint32_t       save_ofs;                                          
    uint32_t       sec = 0;                                           
    uint32_t       byte = 0;                                          
    uint32_t       c = 0;                                             
                                                                      
    if ( count == 0 )                                                 
   21ea0:	e2534000 	subs	r4, r3, #0                                   <== NOT EXECUTED
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    const uint8_t                        *buf                         
    )                                                                 
{                                                                     
   21ea4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   21ea8:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
   21eac:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
    int            rc = 0;                                            
    ssize_t        ret = 0;                                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   21eb0:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t       save_ofs;                                          
    uint32_t       sec = 0;                                           
    uint32_t       byte = 0;                                          
    uint32_t       c = 0;                                             
                                                                      
    if ( count == 0 )                                                 
   21eb4:	01a01004 	moveq	r1, r4                                      <== NOT EXECUTED
   21eb8:	0a000081 	beq	220c4 <fat_file_write+0x228>                  <== NOT EXECUTED
        return cmpltd;                                                
                                                                      
    if ( start > fat_fd->fat_file_size )                              
   21ebc:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
   21ec0:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
{                                                                     
    int            rc = 0;                                            
    ssize_t        ret = 0;                                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
   21ec4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    uint32_t       cl_start = 0;                                      
    uint32_t       ofs = 0;                                           
    uint32_t       save_ofs;                                          
    uint32_t       sec = 0;                                           
    uint32_t       byte = 0;                                          
    uint32_t       c = 0;                                             
   21ec8:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
{                                                                     
    int            rc = 0;                                            
    ssize_t        ret = 0;                                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
   21ecc:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
    uint32_t       c = 0;                                             
                                                                      
    if ( count == 0 )                                                 
        return cmpltd;                                                
                                                                      
    if ( start > fat_fd->fat_file_size )                              
   21ed0:	8a000005 	bhi	21eec <fat_file_write+0x50>                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
                                                                      
    if ((count > fat_fd->size_limit) ||                               
   21ed4:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
   21ed8:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
   21edc:	8a000002 	bhi	21eec <fat_file_write+0x50>                   <== NOT EXECUTED
   21ee0:	e0643003 	rsb	r3, r4, r3                                    <== NOT EXECUTED
   21ee4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   21ee8:	9a000003 	bls	21efc <fat_file_write+0x60>                   <== NOT EXECUTED
        (start > fat_fd->size_limit - count))                         
        rtems_set_errno_and_return_minus_one( EIO );                  
   21eec:	eb006c03 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   21ef0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   21ef4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   21ef8:	ea000070 	b	220c0 <fat_file_write+0x224>                    <== NOT EXECUTED
                                                                      
    rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);        
   21efc:	e084a002 	add	sl, r4, r2                                    <== NOT EXECUTED
   21f00:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   21f04:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
   21f08:	ebffff6f 	bl	21ccc <fat_file_extend>                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   21f0c:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   21f10:	1a00006b 	bne	220c4 <fat_file_write+0x228>                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * check whether there was enough room on device to locate        
     * file of 'start + count' bytes                                  
     */                                                               
    if (c != (start + count))                                         
   21f14:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   21f18:	e153000a 	cmp	r3, sl                                        <== NOT EXECUTED
        count = c - start;                                            
   21f1c:	10674003 	rsbne	r4, r7, r3                                  <== NOT EXECUTED
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
   21f20:	e5963020 	ldr	r3, [r6, #32]                                 <== NOT EXECUTED
   21f24:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   21f28:	1a00001e 	bne	21fa8 <fat_file_write+0x10c>                  <== NOT EXECUTED
   21f2c:	e5963024 	ldr	r3, [r6, #36]	; 0x24                          <== NOT EXECUTED
   21f30:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   21f34:	1a00001b 	bne	21fa8 <fat_file_write+0x10c>                  <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
   21f38:	e5d5300a 	ldrb	r3, [r5, #10]                                <== NOT EXECUTED
   21f3c:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
   21f40:	0a000018 	beq	21fa8 <fat_file_write+0x10c>                  <== NOT EXECUTED
    {                                                                 
        sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);   
   21f44:	e596201c 	ldr	r2, [r6, #28]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   21f48:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   21f4c:	e5983034 	ldr	r3, [r8, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   21f50:	1a000003 	bne	21f64 <fat_file_write+0xc8>                   <== NOT EXECUTED
   21f54:	e5d3100a 	ldrb	r1, [r3, #10]                                <== NOT EXECUTED
   21f58:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   21f5c:	1593301c 	ldrne	r3, [r3, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   21f60:	1a000003 	bne	21f74 <fat_file_write+0xd8>                   <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   21f64:	e5931030 	ldr	r1, [r3, #48]	; 0x30                          <== NOT EXECUTED
   21f68:	e5d30005 	ldrb	r0, [r3, #5]                                 <== NOT EXECUTED
   21f6c:	e2423002 	sub	r3, r2, #2                                    <== NOT EXECUTED
   21f70:	e0813013 	add	r3, r1, r3, lsl r0                            <== NOT EXECUTED
        sec += (start >> fs_info->vol.sec_log2);                      
        byte = start & (fs_info->vol.bps - 1);                        
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, count, buf);      
   21f74:	e1d520b0 	ldrh	r2, [r5]                                     <== NOT EXECUTED
   21f78:	e5d51002 	ldrb	r1, [r5, #2]                                 <== NOT EXECUTED
   21f7c:	e59dc034 	ldr	ip, [sp, #52]	; 0x34                          <== NOT EXECUTED
   21f80:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   21f84:	e0831137 	add	r1, r3, r7, lsr r1                            <== NOT EXECUTED
   21f88:	e0072002 	and	r2, r7, r2                                    <== NOT EXECUTED
   21f8c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   21f90:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   21f94:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   21f98:	eb000287 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
        if ( ret < 0 )                                                
   21f9c:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   21fa0:	aa000047 	bge	220c4 <fat_file_write+0x228>                  <== NOT EXECUTED
   21fa4:	ea000045 	b	220c0 <fat_file_write+0x224>                    <== NOT EXECUTED
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
   21fa8:	e5d53008 	ldrb	r3, [r5, #8]                                 <== NOT EXECUTED
   21fac:	e1a03337 	lsr	r3, r7, r3                                    <== NOT EXECUTED
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   21fb0:	e28da00c 	add	sl, sp, #12                                   <== NOT EXECUTED
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
   21fb4:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   21fb8:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
   21fbc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   21fc0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   21fc4:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
   21fc8:	e1d5b0b6 	ldrh	fp, [r5, #6]                                 <== NOT EXECUTED
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   21fcc:	ebfffe5a 	bl	2193c <fat_file_lseek>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   21fd0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
   21fd4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   21fd8:	1a000039 	bne	220c4 <fat_file_write+0x228>                  <== NOT EXECUTED
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
   21fdc:	e24bb001 	sub	fp, fp, #1                                    <== NOT EXECUTED
   21fe0:	e007b00b 	and	fp, r7, fp                                    <== NOT EXECUTED
   21fe4:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
   21fe8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   21fec:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
   21ff0:	ea000027 	b	22094 <fat_file_write+0x1f8>                    <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
   21ff4:	e1d5c0b6 	ldrh	ip, [r5, #6]                                 <== NOT EXECUTED
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
   21ff8:	e59d700c 	ldr	r7, [sp, #12]                                 <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
   21ffc:	e061c00c 	rsb	ip, r1, ip                                    <== NOT EXECUTED
   22000:	e15c0004 	cmp	ip, r4                                        <== NOT EXECUTED
   22004:	21a0c004 	movcs	ip, r4                                      <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22008:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   2200c:	e5983034 	ldr	r3, [r8, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22010:	e2477002 	sub	r7, r7, #2                                    <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22014:	1a000003 	bne	22028 <fat_file_write+0x18c>                  <== NOT EXECUTED
   22018:	e5d3200a 	ldrb	r2, [r3, #10]                                <== NOT EXECUTED
   2201c:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   22020:	1593701c 	ldrne	r7, [r3, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   22024:	1a000002 	bne	22034 <fat_file_write+0x198>                  <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   22028:	e5932030 	ldr	r2, [r3, #48]	; 0x30                          <== NOT EXECUTED
   2202c:	e5d33005 	ldrb	r3, [r3, #5]                                 <== NOT EXECUTED
   22030:	e0827317 	add	r7, r2, r7, lsl r3                            <== NOT EXECUTED
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
   22034:	e1d520b0 	ldrh	r2, [r5]                                     <== NOT EXECUTED
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
   22038:	e5d59002 	ldrb	r9, [r5, #2]                                 <== NOT EXECUTED
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
   2203c:	e59d0034 	ldr	r0, [sp, #52]	; 0x34                          <== NOT EXECUTED
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
   22040:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
   22044:	e0012002 	and	r2, r1, r2                                    <== NOT EXECUTED
   22048:	e080e00a 	add	lr, r0, sl                                    <== NOT EXECUTED
   2204c:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
   22050:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   22054:	e0871931 	add	r1, r7, r1, lsr r9                            <== NOT EXECUTED
   22058:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
   2205c:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
                                                                      
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
   22060:	eb000255 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
        if ( ret < 0 )                                                
   22064:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   22068:	e28d200c 	add	r2, sp, #12                                   <== NOT EXECUTED
   2206c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);       
        sec += (ofs >> fs_info->vol.sec_log2);                        
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
        if ( ret < 0 )                                                
   22070:	ba000012 	blt	220c0 <fat_file_write+0x224>                  <== NOT EXECUTED
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
   22074:	e59d900c 	ldr	r9, [sp, #12]                                 <== NOT EXECUTED
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   22078:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
   2207c:	e59d7008 	ldr	r7, [sp, #8]                                  <== NOT EXECUTED
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);        
   22080:	eb005ca4 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   22084:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   22088:	1a00000d 	bne	220c4 <fat_file_write+0x228>                  <== NOT EXECUTED
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
   2208c:	e08aa007 	add	sl, sl, r7                                    <== NOT EXECUTED
                                                                      
        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd); 
        if ( ret < 0 )                                                
            return -1;                                                
                                                                      
        count -= c;                                                   
   22090:	e0674004 	rsb	r4, r7, r4                                    <== NOT EXECUTED
                                                                      
    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);        
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
   22094:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   22098:	1affffd5 	bne	21ff4 <fat_file_write+0x158>                  <== NOT EXECUTED
        ofs = 0;                                                      
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
   2209c:	e5d53008 	ldrb	r3, [r5, #8]                                 <== NOT EXECUTED
   220a0:	e24bb001 	sub	fp, fp, #1                                    <== NOT EXECUTED
   220a4:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
   220a8:	e08bb00a 	add	fp, fp, sl                                    <== NOT EXECUTED
   220ac:	e082b33b 	add	fp, r2, fp, lsr r3                            <== NOT EXECUTED
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
    fat_fd->map.disk_cln = save_cln;                                  
   220b0:	e5869038 	str	r9, [r6, #56]	; 0x38                          <== NOT EXECUTED
        ofs = 0;                                                      
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
   220b4:	e586b034 	str	fp, [r6, #52]	; 0x34                          <== NOT EXECUTED
                           ((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
    fat_fd->map.disk_cln = save_cln;                                  
                                                                      
    return cmpltd;                                                    
   220b8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   220bc:	ea000000 	b	220c4 <fat_file_write+0x228>                    <== NOT EXECUTED
   220c0:	e3e01000 	mvn	r1, #0                                        <== NOT EXECUTED
}                                                                     
   220c4:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   220c8:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   220cc:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00039480 <fat_free_fat_clusters_chain>: int fat_free_fat_clusters_chain( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t chain ) {
   39480:	e92d47f1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, lr}         <== NOT EXECUTED
    int            rc = RC_OK, rc1 = RC_OK;                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
   39484:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   39488:	e28da004 	add	sl, sp, #4                                    <== NOT EXECUTED
int                                                                   
fat_free_fat_clusters_chain(                                          
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              chain                       
    )                                                                 
{                                                                     
   3948c:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
   39490:	e1a09001 	mov	r9, r1                                        <== NOT EXECUTED
    int            rc = RC_OK, rc1 = RC_OK;                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
   39494:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
   39498:	e52a3004 	str	r3, [sl, #-4]!                                <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              chain                       
    )                                                                 
{                                                                     
    int            rc = RC_OK, rc1 = RC_OK;                           
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   3949c:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
   394a0:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   394a4:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   394a8:	ea000011 	b	394f4 <fat_free_fat_clusters_chain+0x74>        <== NOT EXECUTED
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);       
   394ac:	ebffff99 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
                                                                      
            fat_buf_release(fs_info);                                 
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE); 
   394b0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);       
        if ( rc != RC_OK )                                            
   394b4:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
                                                                      
            fat_buf_release(fs_info);                                 
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE); 
   394b8:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   394bc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);       
        if ( rc != RC_OK )                                            
   394c0:	0a000006 	beq	394e0 <fat_free_fat_clusters_chain+0x60>      <== NOT EXECUTED
        {                                                             
              if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)        
   394c4:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
   394c8:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
                fs_info->vol.free_cls += freed_cls_cnt;               
   394cc:	10855003 	addne	r5, r5, r3                                  <== NOT EXECUTED
   394d0:	15845040 	strne	r5, [r4, #64]	; 0x40                        <== NOT EXECUTED
                                                                      
            fat_buf_release(fs_info);                                 
   394d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   394d8:	ebffa471 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
            return rc;                                                
   394dc:	ea000014 	b	39534 <fat_free_fat_clusters_chain+0xb4>        <== NOT EXECUTED
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE); 
   394e0:	ebfffef4 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
            rc1 = rc;                                                 
                                                                      
        freed_cls_cnt++;                                              
        cur_cln = next_cln;                                           
   394e4:	e59d6000 	ldr	r6, [sp]                                      <== NOT EXECUTED
            fat_buf_release(fs_info);                                 
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE); 
        if ( rc != RC_OK )                                            
   394e8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   394ec:	11a07000 	movne	r7, r0                                      <== NOT EXECUTED
            rc1 = rc;                                                 
                                                                      
        freed_cls_cnt++;                                              
   394f0:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   394f4:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
   394f8:	e8931008 	ldm	r3, {r3, ip}                                  <== NOT EXECUTED
   394fc:	e0063003 	and	r3, r6, r3                                    <== NOT EXECUTED
   39500:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);       
   39504:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   39508:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   3950c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   39510:	3affffe5 	bcc	394ac <fat_free_fat_clusters_chain+0x2c>      <== NOT EXECUTED
        freed_cls_cnt++;                                              
        cur_cln = next_cln;                                           
    }                                                                 
                                                                      
        fs_info->vol.next_cl = chain;                                 
        if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)             
   39514:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
   39518:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
            fs_info->vol.free_cls += freed_cls_cnt;                   
   3951c:	10855003 	addne	r5, r5, r3                                  <== NOT EXECUTED
                                                                      
        freed_cls_cnt++;                                              
        cur_cln = next_cln;                                           
    }                                                                 
                                                                      
        fs_info->vol.next_cl = chain;                                 
   39520:	e5849044 	str	r9, [r4, #68]	; 0x44                          <== NOT EXECUTED
        if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)             
            fs_info->vol.free_cls += freed_cls_cnt;                   
   39524:	15845040 	strne	r5, [r4, #64]	; 0x40                        <== NOT EXECUTED
                                                                      
    fat_buf_release(fs_info);                                         
   39528:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3952c:	ebffa45c 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
   39530:	e1a06007 	mov	r6, r7                                        <== NOT EXECUTED
    if (rc1 != RC_OK)                                                 
        return rc1;                                                   
                                                                      
    return RC_OK;                                                     
}                                                                     
   39534:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   39538:	e8bd87f8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, pc}          <== NOT EXECUTED
                                                                      

000225ac <fat_free_unique_ino>: fat_free_unique_ino( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t ino ) { fat_fs_info_t *fs_info = mt_entry->fs_info;
   225ac:	e5903034 	ldr	r3, [r0, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino); 
   225b0:	e5932078 	ldr	r2, [r3, #120]	; 0x78                         <== NOT EXECUTED
   225b4:	e593306c 	ldr	r3, [r3, #108]	; 0x6c                         <== NOT EXECUTED
   225b8:	e0622001 	rsb	r2, r2, r1                                    <== NOT EXECUTED
   225bc:	e7d301a2 	ldrb	r0, [r3, r2, lsr #3]                         <== NOT EXECUTED
   225c0:	e2021007 	and	r1, r2, #7                                    <== NOT EXECUTED
   225c4:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
   225c8:	e1c0111c 	bic	r1, r0, ip, lsl r1                            <== NOT EXECUTED
   225cc:	e7c311a2 	strb	r1, [r3, r2, lsr #3]                         <== NOT EXECUTED
}                                                                     
   225d0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00039318 <fat_get_fat_cluster>: fat_get_fat_cluster( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t cln, uint32_t *ret_val ) {
   39318:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
    int                     rc = RC_OK;                               
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
    rtems_bdbuf_buffer     *block0 = NULL;                            
   3931c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    uint32_t                sec = 0;                                  
    uint32_t                ofs = 0;                                  
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
   39320:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
fat_get_fat_cluster(                                                  
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    uint32_t                             *ret_val                     
    )                                                                 
{                                                                     
   39324:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    int                     rc = RC_OK;                               
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
    rtems_bdbuf_buffer     *block0 = NULL;                            
   39328:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
fat_get_fat_cluster(                                                  
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    uint32_t                             *ret_val                     
    )                                                                 
{                                                                     
   3932c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
    int                     rc = RC_OK;                               
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   39330:	e5906034 	ldr	r6, [r0, #52]	; 0x34                          <== NOT EXECUTED
    rtems_bdbuf_buffer     *block0 = NULL;                            
    uint32_t                sec = 0;                                  
    uint32_t                ofs = 0;                                  
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
   39334:	9a00004b 	bls	39468 <fat_get_fat_cluster+0x150>             <== NOT EXECUTED
   39338:	e5963034 	ldr	r3, [r6, #52]	; 0x34                          <== NOT EXECUTED
   3933c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   39340:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
   39344:	8a000047 	bhi	39468 <fat_get_fat_cluster+0x150>             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
   39348:	e5d6300a 	ldrb	r3, [r6, #10]                                <== NOT EXECUTED
   3934c:	e2130001 	ands	r0, r3, #1                                   <== NOT EXECUTED
   39350:	108120a1 	addne	r2, r1, r1, lsr #1                          <== NOT EXECUTED
   39354:	1a000002 	bne	39364 <fat_get_fat_cluster+0x4c>              <== NOT EXECUTED
   39358:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
   3935c:	11a02081 	lslne	r2, r1, #1                                  <== NOT EXECUTED
   39360:	01a02101 	lsleq	r2, r1, #2                                  <== NOT EXECUTED
   39364:	e5d6a002 	ldrb	sl, [r6, #2]                                 <== NOT EXECUTED
   39368:	e596104c 	ldr	r1, [r6, #76]	; 0x4c                          <== NOT EXECUTED
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   3936c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
   39370:	e081aa32 	add	sl, r1, r2, lsr sl                            <== NOT EXECUTED
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   39374:	108480a4 	addne	r8, r4, r4, lsr #1                          <== NOT EXECUTED
   39378:	1a000002 	bne	39388 <fat_get_fat_cluster+0x70>              <== NOT EXECUTED
   3937c:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
   39380:	11a08084 	lslne	r8, r4, #1                                  <== NOT EXECUTED
   39384:	01a08104 	lsleq	r8, r4, #2                                  <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
   39388:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3938c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   39390:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   39394:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   39398:	e1d6b0b0 	ldrh	fp, [r6]                                     <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
   3939c:	ebffa510 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   393a0:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
   393a4:	e1a0900d 	mov	r9, sp                                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   393a8:	1a000032 	bne	39478 <fat_get_fat_cluster+0x160>             <== NOT EXECUTED
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
   393ac:	e5d6200a 	ldrb	r2, [r6, #10]                                <== NOT EXECUTED
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   393b0:	e24bb001 	sub	fp, fp, #1                                    <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
   393b4:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   393b8:	e008800b 	and	r8, r8, fp                                    <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
   393bc:	0a000020 	beq	39444 <fat_get_fat_cluster+0x12c>             <== NOT EXECUTED
   393c0:	e3520004 	cmp	r2, #4                                        <== NOT EXECUTED
   393c4:	0a000022 	beq	39454 <fat_get_fat_cluster+0x13c>             <== NOT EXECUTED
   393c8:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
   393cc:	1a000025 	bne	39468 <fat_get_fat_cluster+0x150>             <== NOT EXECUTED
        case FAT_FAT12:                                               
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*((uint8_t   *)(block0->buffer + ofs)));      
   393d0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   393d4:	e593b020 	ldr	fp, [r3, #32]                                 <== NOT EXECUTED
            if ( ofs == (fs_info->vol.bps - 1) )                      
   393d8:	e1d610b0 	ldrh	r1, [r6]                                     <== NOT EXECUTED
        case FAT_FAT12:                                               
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*((uint8_t   *)(block0->buffer + ofs)));      
   393dc:	e7db3008 	ldrb	r3, [fp, r8]                                 <== NOT EXECUTED
            if ( ofs == (fs_info->vol.bps - 1) )                      
   393e0:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
   393e4:	e1580001 	cmp	r8, r1                                        <== NOT EXECUTED
        case FAT_FAT12:                                               
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*((uint8_t   *)(block0->buffer + ofs)));      
   393e8:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
                *ret_val |= (*((uint8_t   *)(block0->buffer)))<<8;    
            }                                                         
            else                                                      
            {                                                         
                *ret_val |= (*((uint8_t   *)(block0->buffer + ofs + 1)))<<8;
   393ec:	108b8008 	addne	r8, fp, r8                                  <== NOT EXECUTED
   393f0:	15d82001 	ldrbne	r2, [r8, #1]                               <== NOT EXECUTED
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*((uint8_t   *)(block0->buffer + ofs)));      
            if ( ofs == (fs_info->vol.bps - 1) )                      
   393f4:	1a00000a 	bne	39424 <fat_get_fat_cluster+0x10c>             <== NOT EXECUTED
            {                                                         
                rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
   393f8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   393fc:	e28a1001 	add	r1, sl, #1                                    <== NOT EXECUTED
   39400:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   39404:	ebffa4f6 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
                                    &block0);                         
                if (rc != RC_OK)                                      
   39408:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3940c:	11a07000 	movne	r7, r0                                      <== NOT EXECUTED
   39410:	1a000018 	bne	39478 <fat_get_fat_cluster+0x160>             <== NOT EXECUTED
                    return rc;                                        
                                                                      
                *ret_val |= (*((uint8_t   *)(block0->buffer)))<<8;    
   39414:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39418:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   3941c:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
   39420:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
            }                                                         
            else                                                      
            {                                                         
                *ret_val |= (*((uint8_t   *)(block0->buffer + ofs + 1)))<<8;
   39424:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
   39428:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
   3942c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
            }                                                         
                                                                      
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
   39430:	e3140001 	tst	r4, #1                                        <== NOT EXECUTED
                *ret_val = (*ret_val) >> FAT12_SHIFT;                 
            else                                                      
                *ret_val = (*ret_val) & FAT_FAT12_MASK;               
   39434:	01a03a03 	lsleq	r3, r3, #20                                 <== NOT EXECUTED
            {                                                         
                *ret_val |= (*((uint8_t   *)(block0->buffer + ofs + 1)))<<8;
            }                                                         
                                                                      
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
                *ret_val = (*ret_val) >> FAT12_SHIFT;                 
   39438:	11a03223 	lsrne	r3, r3, #4                                  <== NOT EXECUTED
            else                                                      
                *ret_val = (*ret_val) & FAT_FAT12_MASK;               
   3943c:	01a03a23 	lsreq	r3, r3, #20                                 <== NOT EXECUTED
   39440:	ea000006 	b	39460 <fat_get_fat_cluster+0x148>               <== NOT EXECUTED
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *ret_val = *((uint16_t   *)(block0->buffer + ofs));       
            *ret_val = CF_LE_W(*ret_val);                             
   39444:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39448:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   3944c:	e19330b8 	ldrh	r3, [r3, r8]                                 <== NOT EXECUTED
   39450:	ea000002 	b	39460 <fat_get_fat_cluster+0x148>               <== NOT EXECUTED
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            *ret_val = *((uint32_t   *)(block0->buffer + ofs));       
            *ret_val = CF_LE_L(*ret_val);                             
   39454:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39458:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   3945c:	e7933008 	ldr	r3, [r3, r8]                                  <== NOT EXECUTED
   39460:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
            break;                                                    
   39464:	ea000003 	b	39478 <fat_get_fat_cluster+0x160>               <== NOT EXECUTED
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
   39468:	eb000ea4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3946c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   39470:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   39474:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
            break;                                                    
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
   39478:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   3947c:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

000225ec <fat_get_unique_ino>: * 0 means FAILED !!! * */ uint32_t fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry) {
   225ec:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   225f0:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t                j = 0;                                    
    bool                    resrc_unsuff = false;                     
                                                                      
    while (!resrc_unsuff)                                             
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
   225f4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   225f8:	ea000024 	b	22690 <fat_get_unique_ino+0xa4>                 <== NOT EXECUTED
        {                                                             
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
   225fc:	e5943070 	ldr	r3, [r4, #112]	; 0x70                         <== NOT EXECUTED
   22600:	e594706c 	ldr	r7, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   22604:	e7d701a3 	ldrb	r0, [r7, r3, lsr #3]                         <== NOT EXECUTED
   22608:	e203c007 	and	ip, r3, #7                                    <== NOT EXECUTED
   2260c:	e1a08c50 	asr	r8, r0, ip                                    <== NOT EXECUTED
   22610:	e3180001 	tst	r8, #1                                        <== NOT EXECUTED
            {                                                         
                FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 
                return (fs_info->uino_base + fs_info->index);         
            }                                                         
            fs_info->index++;                                         
   22614:	e2836001 	add	r6, r3, #1                                    <== NOT EXECUTED
                                                                      
    while (!resrc_unsuff)                                             
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
        {                                                             
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
   22618:	e08731a3 	add	r3, r7, r3, lsr #3                            <== NOT EXECUTED
   2261c:	1a000006 	bne	2263c <fat_get_unique_ino+0x50>               <== NOT EXECUTED
            {                                                         
                FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 
   22620:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   22624:	e1800c12 	orr	r0, r0, r2, lsl ip                            <== NOT EXECUTED
   22628:	e5c30000 	strb	r0, [r3]                                     <== NOT EXECUTED
                return (fs_info->uino_base + fs_info->index);         
   2262c:	e5943078 	ldr	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
   22630:	e5940070 	ldr	r0, [r4, #112]	; 0x70                         <== NOT EXECUTED
   22634:	e0800003 	add	r0, r0, r3                                    <== NOT EXECUTED
   22638:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
            }                                                         
            fs_info->index++;                                         
            if (fs_info->index >= fs_info->uino_pool_size)            
   2263c:	e5943074 	ldr	r3, [r4, #116]	; 0x74                         <== NOT EXECUTED
   22640:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
            {                                                         
                FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 
                return (fs_info->uino_base + fs_info->index);         
            }                                                         
            fs_info->index++;                                         
   22644:	e5846070 	str	r6, [r4, #112]	; 0x70                         <== NOT EXECUTED
            if (fs_info->index >= fs_info->uino_pool_size)            
                fs_info->index = 0;                                   
   22648:	25845070 	strcs	r5, [r4, #112]	; 0x70                       <== NOT EXECUTED
    uint32_t                j = 0;                                    
    bool                    resrc_unsuff = false;                     
                                                                      
    while (!resrc_unsuff)                                             
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
   2264c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   22650:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   22654:	3affffe8 	bcc	225fc <fat_get_unique_ino+0x10>               <== NOT EXECUTED
            fs_info->index++;                                         
            if (fs_info->index >= fs_info->uino_pool_size)            
                fs_info->index = 0;                                   
        }                                                             
                                                                      
        if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
   22658:	e5942078 	ldr	r2, [r4, #120]	; 0x78                         <== NOT EXECUTED
   2265c:	e3e0320f 	mvn	r3, #-268435456	; 0xf0000000                  <== NOT EXECUTED
   22660:	e0623003 	rsb	r3, r2, r3                                    <== NOT EXECUTED
   22664:	e1a01081 	lsl	r1, r1, #1                                    <== NOT EXECUTED
   22668:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
   2266c:	2a00000a 	bcs	2269c <fat_get_unique_ino+0xb0>               <== NOT EXECUTED
        {                                                             
            fs_info->uino_pool_size <<= 1;                            
   22670:	e5841074 	str	r1, [r4, #116]	; 0x74                         <== NOT EXECUTED
            fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
   22674:	e594006c 	ldr	r0, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   22678:	ebff9919 	bl	8ae4 <realloc>                                 <== NOT EXECUTED
            if (fs_info->uino != NULL)                                
   2267c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        }                                                             
                                                                      
        if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
        {                                                             
            fs_info->uino_pool_size <<= 1;                            
            fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
   22680:	e584006c 	str	r0, [r4, #108]	; 0x6c                         <== NOT EXECUTED
            if (fs_info->uino != NULL)                                
   22684:	0a000004 	beq	2269c <fat_get_unique_ino+0xb0>               <== NOT EXECUTED
                fs_info->index = fs_info->uino_pool_size;             
   22688:	e5943074 	ldr	r3, [r4, #116]	; 0x74                         <== NOT EXECUTED
   2268c:	e5843070 	str	r3, [r4, #112]	; 0x70                         <== NOT EXECUTED
    uint32_t                j = 0;                                    
    bool                    resrc_unsuff = false;                     
                                                                      
    while (!resrc_unsuff)                                             
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
   22690:	e5941074 	ldr	r1, [r4, #116]	; 0x74                         <== NOT EXECUTED
   22694:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   22698:	eaffffec 	b	22650 <fat_get_unique_ino+0x64>                 <== NOT EXECUTED
   2269c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
        }                                                             
        else                                                          
            resrc_unsuff = true;                                      
    }                                                                 
    return 0;                                                         
}                                                                     
   226a0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00022c00 <fat_init_clusters_chain>: int fat_init_clusters_chain( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t start_cln ) {
   22c00:	e92d41f1 	push	{r0, r4, r5, r6, r7, r8, lr}                 <== NOT EXECUTED
    int                     rc = RC_OK;                               
    ssize_t                 ret = 0;                                  
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   22c04:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t                cur_cln = start_cln;                      
   22c08:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
int                                                                   
fat_init_clusters_chain(                                              
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              start_cln                   
    )                                                                 
{                                                                     
   22c0c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    ssize_t                 ret = 0;                                  
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
    uint32_t                cur_cln = start_cln;                      
    char                   *buf;                                      
                                                                      
    buf = calloc(fs_info->vol.bpc, sizeof(char));                     
   22c10:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   22c14:	e1d500b6 	ldrh	r0, [r5, #6]                                 <== NOT EXECUTED
   22c18:	ebff9135 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if ( buf == NULL )                                                
   22c1c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
        {                                                             
            free(buf);                                                
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);       
   22c20:	11a0700d 	movne	r7, sp                                      <== NOT EXECUTED
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
    uint32_t                cur_cln = start_cln;                      
    char                   *buf;                                      
                                                                      
    buf = calloc(fs_info->vol.bpc, sizeof(char));                     
    if ( buf == NULL )                                                
   22c24:	1a000011 	bne	22c70 <fat_init_clusters_chain+0x70>          <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
   22c28:	eb0068b4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22c2c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   22c30:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   22c34:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
   22c38:	ea000018 	b	22ca0 <fat_init_clusters_chain+0xa0>            <== NOT EXECUTED
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        ret = fat_cluster_write(mt_entry, cur_cln, buf);              
   22c3c:	ebffffdb 	bl	22bb0 <fat_cluster_write>                      <== NOT EXECUTED
   22c40:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
        if ( ret == -1 )                                              
   22c44:	e3780001 	cmn	r8, #1                                        <== NOT EXECUTED
        {                                                             
            free(buf);                                                
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);       
   22c48:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   22c4c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        ret = fat_cluster_write(mt_entry, cur_cln, buf);              
        if ( ret == -1 )                                              
   22c50:	0a000003 	beq	22c64 <fat_init_clusters_chain+0x64>          <== NOT EXECUTED
        {                                                             
            free(buf);                                                
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);       
   22c54:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
   22c58:	eb0059ae 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   22c5c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   22c60:	0a000002 	beq	22c70 <fat_init_clusters_chain+0x70>          <== NOT EXECUTED
        {                                                             
            free(buf);                                                
   22c64:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22c68:	ebff9291 	bl	76b4 <free>                                    <== NOT EXECUTED
            return rc;                                                
   22c6c:	ea00000b 	b	22ca0 <fat_init_clusters_chain+0xa0>            <== NOT EXECUTED
                                                                      
    buf = calloc(fs_info->vol.bpc, sizeof(char));                     
    if ( buf == NULL )                                                
        rtems_set_errno_and_return_minus_one( EIO );                  
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   22c70:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   22c74:	e595e00c 	ldr	lr, [r5, #12]                                 <== NOT EXECUTED
   22c78:	e595c010 	ldr	ip, [r5, #16]                                 <== NOT EXECUTED
    {                                                                 
        ret = fat_cluster_write(mt_entry, cur_cln, buf);              
   22c7c:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
                                                                      
    buf = calloc(fs_info->vol.bpc, sizeof(char));                     
    if ( buf == NULL )                                                
        rtems_set_errno_and_return_minus_one( EIO );                  
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   22c80:	e003300e 	and	r3, r3, lr                                    <== NOT EXECUTED
   22c84:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
    {                                                                 
        ret = fat_cluster_write(mt_entry, cur_cln, buf);              
   22c88:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   22c8c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
    buf = calloc(fs_info->vol.bpc, sizeof(char));                     
    if ( buf == NULL )                                                
        rtems_set_errno_and_return_minus_one( EIO );                  
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
   22c90:	3affffe9 	bcc	22c3c <fat_init_clusters_chain+0x3c>          <== NOT EXECUTED
            free(buf);                                                
            return rc;                                                
        }                                                             
                                                                      
    }                                                                 
    free(buf);                                                        
   22c94:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22c98:	ebff9285 	bl	76b4 <free>                                    <== NOT EXECUTED
   22c9c:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   22ca0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   22ca4:	e8bd81f8 	pop	{r3, r4, r5, r6, r7, r8, pc}                  <== NOT EXECUTED
                                                                      

00022d38 <fat_init_volume_info>: * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry) {
   22d38:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   22d3c:	e24dd0b8 	sub	sp, sp, #184	; 0xb8                           <== NOT EXECUTED
   22d40:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    char                boot_rec[FAT_MAX_BPB_SIZE];                   
    char                fs_info_sector[FAT_USEFUL_INFO_SIZE];         
    ssize_t             ret = 0;                                      
    struct stat         stat_buf;                                     
    int                 i = 0;                                        
    rtems_bdbuf_buffer *block = NULL;                                 
   22d44:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
                                                                      
    rc = stat(mt_entry->dev, &stat_buf);                              
   22d48:	e5900070 	ldr	r0, [r0, #112]	; 0x70                         <== NOT EXECUTED
   22d4c:	e28d1060 	add	r1, sp, #96	; 0x60                            <== NOT EXECUTED
    char                boot_rec[FAT_MAX_BPB_SIZE];                   
    char                fs_info_sector[FAT_USEFUL_INFO_SIZE];         
    ssize_t             ret = 0;                                      
    struct stat         stat_buf;                                     
    int                 i = 0;                                        
    rtems_bdbuf_buffer *block = NULL;                                 
   22d50:	e58d60b4 	str	r6, [sp, #180]	; 0xb4                         <== NOT EXECUTED
int                                                                   
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)  
{                                                                     
    rtems_status_code   sc = RTEMS_SUCCESSFUL;                        
    int                 rc = RC_OK;                                   
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
   22d54:	e5954034 	ldr	r4, [r5, #52]	; 0x34                          <== NOT EXECUTED
    ssize_t             ret = 0;                                      
    struct stat         stat_buf;                                     
    int                 i = 0;                                        
    rtems_bdbuf_buffer *block = NULL;                                 
                                                                      
    rc = stat(mt_entry->dev, &stat_buf);                              
   22d58:	ebff9835 	bl	8e34 <stat>                                    <== NOT EXECUTED
    if (rc == -1)                                                     
   22d5c:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
    ssize_t             ret = 0;                                      
    struct stat         stat_buf;                                     
    int                 i = 0;                                        
    rtems_bdbuf_buffer *block = NULL;                                 
                                                                      
    rc = stat(mt_entry->dev, &stat_buf);                              
   22d60:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    if (rc == -1)                                                     
   22d64:	0a000167 	beq	23308 <fat_init_volume_info+0x5d0>            <== NOT EXECUTED
        return rc;                                                    
                                                                      
    /* Must be a block device. */                                     
    if (!S_ISBLK(stat_buf.st_mode))                                   
   22d68:	e59d306c 	ldr	r3, [sp, #108]	; 0x6c                         <== NOT EXECUTED
   22d6c:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   22d70:	e3530a06 	cmp	r3, #24576	; 0x6000                           <== NOT EXECUTED
   22d74:	0a000002 	beq	22d84 <fat_init_volume_info+0x4c>             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOTTY);                 
   22d78:	eb006860 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22d7c:	e3a03019 	mov	r3, #25                                       <== NOT EXECUTED
   22d80:	ea00015e 	b	23300 <fat_init_volume_info+0x5c8>              <== NOT EXECUTED
                                                                      
    /* check that device is registred as block device and lock it */  
    vol->dd = rtems_disk_obtain(stat_buf.st_rdev);                    
   22d84:	e28d1078 	add	r1, sp, #120	; 0x78                           <== NOT EXECUTED
   22d88:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   22d8c:	ebff8d42 	bl	629c <rtems_disk_obtain>                       <== NOT EXECUTED
    if (vol->dd == NULL)                                              
   22d90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    /* Must be a block device. */                                     
    if (!S_ISBLK(stat_buf.st_mode))                                   
        rtems_set_errno_and_return_minus_one(ENOTTY);                 
                                                                      
    /* check that device is registred as block device and lock it */  
    vol->dd = rtems_disk_obtain(stat_buf.st_rdev);                    
   22d94:	e584005c 	str	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    if (vol->dd == NULL)                                              
   22d98:	0a00000a 	beq	22dc8 <fat_init_volume_info+0x90>             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    vol->dev = stat_buf.st_rdev;                                      
   22d9c:	e28d1078 	add	r1, sp, #120	; 0x78                           <== NOT EXECUTED
   22da0:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
                                                                      
    /* Read boot record */                                            
    /* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */          
    sc = rtems_bdbuf_read( vol->dev, 0, &block);                      
   22da4:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
    /* check that device is registred as block device and lock it */  
    vol->dd = rtems_disk_obtain(stat_buf.st_rdev);                    
    if (vol->dd == NULL)                                              
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    vol->dev = stat_buf.st_rdev;                                      
   22da8:	e5840054 	str	r0, [r4, #84]	; 0x54                          <== NOT EXECUTED
   22dac:	e5841058 	str	r1, [r4, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    /* Read boot record */                                            
    /* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */          
    sc = rtems_bdbuf_read( vol->dev, 0, &block);                      
   22db0:	e28d30b4 	add	r3, sp, #180	; 0xb4                           <== NOT EXECUTED
   22db4:	ebff894b 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
   22db8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22dbc:	0a000004 	beq	22dd4 <fat_init_volume_info+0x9c>             <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
   22dc0:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   22dc4:	ebff8db0 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO);                   
   22dc8:	eb00684c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22dcc:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   22dd0:	ea00014a 	b	23300 <fat_init_volume_info+0x5c8>              <== NOT EXECUTED
    }                                                                 
                                                                      
    memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);               
   22dd4:	e59d30b4 	ldr	r3, [sp, #180]	; 0xb4                         <== NOT EXECUTED
   22dd8:	e3a0205a 	mov	r2, #90	; 0x5a                                <== NOT EXECUTED
   22ddc:	e5931020 	ldr	r1, [r3, #32]                                 <== NOT EXECUTED
   22de0:	e28d0004 	add	r0, sp, #4                                    <== NOT EXECUTED
   22de4:	eb0074f5 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
    sc = rtems_bdbuf_release( block);                                 
   22de8:	e59d00b4 	ldr	r0, [sp, #180]	; 0xb4                         <== NOT EXECUTED
   22dec:	ebff84fd 	bl	41e8 <rtems_bdbuf_release>                     <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
   22df0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22df4:	1afffff1 	bne	22dc0 <fat_init_volume_info+0x88>             <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one( EIO );                  
    }                                                                 
                                                                      
    /* Evaluate boot record */                                        
    vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);                 
   22df8:	e5dd2010 	ldrb	r2, [sp, #16]                                <== NOT EXECUTED
   22dfc:	e5dd300f 	ldrb	r3, [sp, #15]                                <== NOT EXECUTED
   22e00:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
                                                                      
    if ( (vol->bps != 512)  &&                                        
   22e04:	e3530b01 	cmp	r3, #1024	; 0x400                             <== NOT EXECUTED
   22e08:	13530c02 	cmpne	r3, #512	; 0x200                            <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one( EIO );                  
    }                                                                 
                                                                      
    /* Evaluate boot record */                                        
    vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);                 
   22e0c:	e1c430b0 	strh	r3, [r4]                                     <== NOT EXECUTED
                                                                      
    if ( (vol->bps != 512)  &&                                        
   22e10:	0a000003 	beq	22e24 <fat_init_volume_info+0xec>             <== NOT EXECUTED
   22e14:	e3530b02 	cmp	r3, #2048	; 0x800                             <== NOT EXECUTED
   22e18:	0a000001 	beq	22e24 <fat_init_volume_info+0xec>             <== NOT EXECUTED
   22e1c:	e3530a01 	cmp	r3, #4096	; 0x1000                            <== NOT EXECUTED
   22e20:	1a0000ad 	bne	230dc <fat_init_volume_info+0x3a4>            <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one( EINVAL );               
    }                                                                 
                                                                      
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
   22e24:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   22e28:	e5c42003 	strb	r2, [r4, #3]                                 <== NOT EXECUTED
   22e2c:	e1a034a3 	lsr	r3, r3, #9                                    <== NOT EXECUTED
   22e30:	ea000003 	b	22e44 <fat_init_volume_info+0x10c>              <== NOT EXECUTED
         i >>= 1, vol->sec_mul++);                                    
   22e34:	e5d42003 	ldrb	r2, [r4, #3]                                 <== NOT EXECUTED
   22e38:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   22e3c:	e5c42003 	strb	r2, [r4, #3]                                 <== NOT EXECUTED
   22e40:	e1a030c3 	asr	r3, r3, #1                                    <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one( EINVAL );               
    }                                                                 
                                                                      
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
   22e44:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
   22e48:	0afffff9 	beq	22e34 <fat_init_volume_info+0xfc>             <== NOT EXECUTED
         i >>= 1, vol->sec_mul++);                                    
    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;               
   22e4c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   22e50:	e5c43002 	strb	r3, [r4, #2]                                 <== NOT EXECUTED
   22e54:	e1d430b0 	ldrh	r3, [r4]                                     <== NOT EXECUTED
   22e58:	ea000003 	b	22e6c <fat_init_volume_info+0x134>              <== NOT EXECUTED
         i >>= 1, vol->sec_log2++);                                   
   22e5c:	e5d42002 	ldrb	r2, [r4, #2]                                 <== NOT EXECUTED
   22e60:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   22e64:	e5c42002 	strb	r2, [r4, #2]                                 <== NOT EXECUTED
   22e68:	e1a030c3 	asr	r3, r3, #1                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EINVAL );               
    }                                                                 
                                                                      
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
         i >>= 1, vol->sec_mul++);                                    
    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;               
   22e6c:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
   22e70:	0afffff9 	beq	22e5c <fat_init_volume_info+0x124>            <== NOT EXECUTED
         i >>= 1, vol->sec_log2++);                                   
                                                                      
    vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);              
   22e74:	e5dd2011 	ldrb	r2, [sp, #17]                                <== NOT EXECUTED
    /*                                                                
     * "sectors per cluster" of zero is invalid                       
     * (and would hang the following loop)                            
     */                                                               
    if (vol->spc == 0)                                                
   22e78:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
   22e7c:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
    for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
         i >>= 1, vol->sec_mul++);                                    
    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;               
         i >>= 1, vol->sec_log2++);                                   
                                                                      
    vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);              
   22e80:	e5c42004 	strb	r2, [r4, #4]                                 <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
   22e84:	15c43005 	strbne	r3, [r4, #5]                               <== NOT EXECUTED
    vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);              
    /*                                                                
     * "sectors per cluster" of zero is invalid                       
     * (and would hang the following loop)                            
     */                                                               
    if (vol->spc == 0)                                                
   22e88:	1a000003 	bne	22e9c <fat_init_volume_info+0x164>            <== NOT EXECUTED
   22e8c:	ea000092 	b	230dc <fat_init_volume_info+0x3a4>              <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
         i >>= 1, vol->spc_log2++);                                   
   22e90:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   22e94:	e5c43005 	strb	r3, [r4, #5]                                 <== NOT EXECUTED
   22e98:	e1a020c2 	asr	r2, r2, #1                                    <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
   22e9c:	e3120001 	tst	r2, #1                                        <== NOT EXECUTED
   22ea0:	e5d43005 	ldrb	r3, [r4, #5]                                 <== NOT EXECUTED
   22ea4:	0afffff9 	beq	22e90 <fat_init_volume_info+0x158>            <== NOT EXECUTED
         i >>= 1, vol->spc_log2++);                                   
                                                                      
    /*                                                                
     * "bytes per cluster" value greater than 32K is invalid          
     */                                                               
    if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
   22ea8:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
   22eac:	e1a03312 	lsl	r3, r2, r3                                    <== NOT EXECUTED
   22eb0:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
   22eb4:	e1a03823 	lsr	r3, r3, #16                                   <== NOT EXECUTED
   22eb8:	e3530902 	cmp	r3, #32768	; 0x8000                           <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
   22ebc:	93a02000 	movls	r2, #0                                      <== NOT EXECUTED
         i >>= 1, vol->spc_log2++);                                   
                                                                      
    /*                                                                
     * "bytes per cluster" value greater than 32K is invalid          
     */                                                               
    if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
   22ec0:	e1c430b6 	strh	r3, [r4, #6]                                 <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
   22ec4:	95c42008 	strbls	r2, [r4, #8]                               <== NOT EXECUTED
         i >>= 1, vol->spc_log2++);                                   
                                                                      
    /*                                                                
     * "bytes per cluster" value greater than 32K is invalid          
     */                                                               
    if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
   22ec8:	9a000004 	bls	22ee0 <fat_init_volume_info+0x1a8>            <== NOT EXECUTED
   22ecc:	ea000082 	b	230dc <fat_init_volume_info+0x3a4>              <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
         i >>= 1, vol->bpc_log2++);                                   
   22ed0:	e5d42008 	ldrb	r2, [r4, #8]                                 <== NOT EXECUTED
   22ed4:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   22ed8:	e5c42008 	strb	r2, [r4, #8]                                 <== NOT EXECUTED
   22edc:	e1a030c3 	asr	r3, r3, #1                                    <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
   22ee0:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
   22ee4:	0afffff9 	beq	22ed0 <fat_init_volume_info+0x198>            <== NOT EXECUTED
         i >>= 1, vol->bpc_log2++);                                   
                                                                      
    vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);                         
   22ee8:	e5dd3014 	ldrb	r3, [sp, #20]                                <== NOT EXECUTED
   22eec:	e5c43009 	strb	r3, [r4, #9]                                 <== NOT EXECUTED
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
   22ef0:	e5dd2013 	ldrb	r2, [sp, #19]                                <== NOT EXECUTED
   22ef4:	e5dd3012 	ldrb	r3, [sp, #18]                                <== NOT EXECUTED
   22ef8:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
   22efc:	e1c431b4 	strh	r3, [r4, #20]                                <== NOT EXECUTED
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
   22f00:	e1d410b0 	ldrh	r1, [r4]                                     <== NOT EXECUTED
         i >>= 1, vol->bpc_log2++);                                   
                                                                      
    vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);                         
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
   22f04:	e5dd2016 	ldrb	r2, [sp, #22]                                <== NOT EXECUTED
   22f08:	e5dd3015 	ldrb	r3, [sp, #21]                                <== NOT EXECUTED
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
   22f0c:	e2410001 	sub	r0, r1, #1                                    <== NOT EXECUTED
         i >>= 1, vol->bpc_log2++);                                   
                                                                      
    vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);                         
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
   22f10:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
   22f14:	e0800283 	add	r0, r0, r3, lsl #5                            <== NOT EXECUTED
         i >>= 1, vol->bpc_log2++);                                   
                                                                      
    vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);                         
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
   22f18:	e1c432b0 	strh	r3, [r4, #32]                                <== NOT EXECUTED
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
   22f1c:	eb00c7f9 	bl	54f08 <__aeabi_idiv>                           <== NOT EXECUTED
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
   22f20:	e5d43002 	ldrb	r3, [r4, #2]                                 <== NOT EXECUTED
   22f24:	e1a03310 	lsl	r3, r0, r3                                    <== NOT EXECUTED
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
   22f28:	e5840024 	str	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
   22f2c:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
    if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)                 
   22f30:	e5dd201b 	ldrb	r2, [sp, #27]                                <== NOT EXECUTED
   22f34:	e5dd301a 	ldrb	r3, [sp, #26]                                <== NOT EXECUTED
   22f38:	e1933402 	orrs	r3, r3, r2, lsl #8                           <== NOT EXECUTED
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);       
    else                                                              
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);     
   22f3c:	05dd302a 	ldrbeq	r3, [sp, #42]	; 0x2a                       <== NOT EXECUTED
   22f40:	05dd2029 	ldrbeq	r2, [sp, #41]	; 0x29                       <== NOT EXECUTED
   22f44:	05dd1028 	ldrbeq	r1, [sp, #40]	; 0x28                       <== NOT EXECUTED
   22f48:	01a03803 	lsleq	r3, r3, #16                                 <== NOT EXECUTED
   22f4c:	01833402 	orreq	r3, r3, r2, lsl #8                          <== NOT EXECUTED
   22f50:	05dd202b 	ldrbeq	r2, [sp, #43]	; 0x2b                       <== NOT EXECUTED
   22f54:	01833001 	orreq	r3, r3, r1                                  <== NOT EXECUTED
   22f58:	01833c02 	orreq	r3, r3, r2, lsl #24                         <== NOT EXECUTED
   22f5c:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
                                                                      
    vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +     
   22f60:	e5d42009 	ldrb	r2, [r4, #9]                                 <== NOT EXECUTED
   22f64:	e5941018 	ldr	r1, [r4, #24]                                 <== NOT EXECUTED
   22f68:	e0030291 	mul	r3, r1, r2                                    <== NOT EXECUTED
   22f6c:	e1d421b4 	ldrh	r2, [r4, #20]                                <== NOT EXECUTED
   22f70:	e5941024 	ldr	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
   22f74:	e0821001 	add	r1, r2, r1                                    <== NOT EXECUTED
                     vol->rdir_secs;                                  
                                                                      
    /* for  FAT12/16 root dir starts at(sector) */                    
    vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;       
   22f78:	e0832002 	add	r2, r3, r2                                    <== NOT EXECUTED
    if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)                 
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);       
    else                                                              
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);     
                                                                      
    vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +     
   22f7c:	e0813003 	add	r3, r1, r3                                    <== NOT EXECUTED
   22f80:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
                     vol->rdir_secs;                                  
                                                                      
    /* for  FAT12/16 root dir starts at(sector) */                    
    vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;       
   22f84:	e584201c 	str	r2, [r4, #28]                                 <== NOT EXECUTED
                                                                      
    if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)             
   22f88:	e5dd2018 	ldrb	r2, [sp, #24]                                <== NOT EXECUTED
   22f8c:	e5dd3017 	ldrb	r3, [sp, #23]                                <== NOT EXECUTED
   22f90:	e1933402 	orrs	r3, r3, r2, lsl #8                           <== NOT EXECUTED
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);     
    else                                                              
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);     
   22f94:	05dd3026 	ldrbeq	r3, [sp, #38]	; 0x26                       <== NOT EXECUTED
   22f98:	05dd2025 	ldrbeq	r2, [sp, #37]	; 0x25                       <== NOT EXECUTED
   22f9c:	01a03803 	lsleq	r3, r3, #16                                 <== NOT EXECUTED
   22fa0:	05dd1024 	ldrbeq	r1, [sp, #36]	; 0x24                       <== NOT EXECUTED
   22fa4:	01833402 	orreq	r3, r3, r2, lsl #8                          <== NOT EXECUTED
   22fa8:	05dd2027 	ldrbeq	r2, [sp, #39]	; 0x27                       <== NOT EXECUTED
   22fac:	01833001 	orreq	r3, r3, r1                                  <== NOT EXECUTED
   22fb0:	01833c02 	orreq	r3, r3, r2, lsl #24                         <== NOT EXECUTED
   22fb4:	e584302c 	str	r3, [r4, #44]	; 0x2c                          <== NOT EXECUTED
                                                                      
    data_secs = vol->tot_secs - vol->data_fsec;                       
                                                                      
    vol->data_cls = data_secs / vol->spc;                             
   22fb8:	e5d41004 	ldrb	r1, [r4, #4]                                 <== NOT EXECUTED
   22fbc:	e284302c 	add	r3, r4, #44	; 0x2c                            <== NOT EXECUTED
   22fc0:	e8930009 	ldm	r3, {r0, r3}                                  <== NOT EXECUTED
   22fc4:	e0400003 	sub	r0, r0, r3                                    <== NOT EXECUTED
   22fc8:	eb00c78a 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
    /* determine FAT type at least */                                 
    if ( vol->data_cls < FAT_FAT12_MAX_CLN)                           
   22fcc:	e59f3340 	ldr	r3, [pc, #832]	; 23314 <fat_init_volume_info+0x5dc><== NOT EXECUTED
   22fd0:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    else                                                              
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);     
                                                                      
    data_secs = vol->tot_secs - vol->data_fsec;                       
                                                                      
    vol->data_cls = data_secs / vol->spc;                             
   22fd4:	e5840034 	str	r0, [r4, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    /* determine FAT type at least */                                 
    if ( vol->data_cls < FAT_FAT12_MAX_CLN)                           
    {                                                                 
        vol->type = FAT_FAT12;                                        
   22fd8:	93a03001 	movls	r3, #1                                      <== NOT EXECUTED
   22fdc:	95c4300a 	strbls	r3, [r4, #10]                              <== NOT EXECUTED
        vol->mask = FAT_FAT12_MASK;                                   
   22fe0:	959f3330 	ldrls	r3, [pc, #816]	; 23318 <fat_init_volume_info+0x5e0><== NOT EXECUTED
   22fe4:	9a000005 	bls	23000 <fat_init_volume_info+0x2c8>            <== NOT EXECUTED
        vol->eoc_val = FAT_FAT12_EOC;                                 
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
   22fe8:	e59f332c 	ldr	r3, [pc, #812]	; 2331c <fat_init_volume_info+0x5e4><== NOT EXECUTED
   22fec:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
   22ff0:	8a000005 	bhi	2300c <fat_init_volume_info+0x2d4>            <== NOT EXECUTED
        {                                                             
            vol->type = FAT_FAT16;                                    
   22ff4:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   22ff8:	e5c4300a 	strb	r3, [r4, #10]                                <== NOT EXECUTED
            vol->mask = FAT_FAT16_MASK;                               
   22ffc:	e59f331c 	ldr	r3, [pc, #796]	; 23320 <fat_init_volume_info+0x5e8><== NOT EXECUTED
   23000:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
            vol->eoc_val = FAT_FAT16_EOC;                             
   23004:	e2433007 	sub	r3, r3, #7                                    <== NOT EXECUTED
   23008:	ea000004 	b	23020 <fat_init_volume_info+0x2e8>              <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
   2300c:	e3a03004 	mov	r3, #4                                        <== NOT EXECUTED
   23010:	e5c4300a 	strb	r3, [r4, #10]                                <== NOT EXECUTED
            vol->mask = FAT_FAT32_MASK;                               
   23014:	e3e0320f 	mvn	r3, #-268435456	; 0xf0000000                  <== NOT EXECUTED
   23018:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
            vol->eoc_val = FAT_FAT32_EOC;                             
   2301c:	e3e0327f 	mvn	r3, #-268435449	; 0xf0000007                  <== NOT EXECUTED
   23020:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)  
{                                                                     
    rtems_status_code   sc = RTEMS_SUCCESSFUL;                        
    int                 rc = RC_OK;                                   
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
    register fat_vol_t *vol = &fs_info->vol;                          
   23024:	e5d4300a 	ldrb	r3, [r4, #10]                                <== NOT EXECUTED
   23028:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
   2302c:	1a000059 	bne	23198 <fat_init_volume_info+0x460>            <== NOT EXECUTED
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
   23030:	e5dd3032 	ldrb	r3, [sp, #50]	; 0x32                         <== NOT EXECUTED
   23034:	e5dd2031 	ldrb	r2, [sp, #49]	; 0x31                         <== NOT EXECUTED
   23038:	e5dd1030 	ldrb	r1, [sp, #48]	; 0x30                         <== NOT EXECUTED
   2303c:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
   23040:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
   23044:	e5dd2033 	ldrb	r2, [sp, #51]	; 0x33                         <== NOT EXECUTED
   23048:	e1833001 	orr	r3, r3, r1                                    <== NOT EXECUTED
   2304c:	e1833c02 	orr	r3, r3, r2, lsl #24                           <== NOT EXECUTED
   23050:	e5843038 	str	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
   23054:	e5dd302c 	ldrb	r3, [sp, #44]	; 0x2c                         <== NOT EXECUTED
   23058:	e2033080 	and	r3, r3, #128	; 0x80                           <== NOT EXECUTED
   2305c:	e5c43048 	strb	r3, [r4, #72]	; 0x48                         <== NOT EXECUTED
        if (vol->mirror)                                              
   23060:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
   23064:	15dd302c 	ldrbne	r3, [sp, #44]	; 0x2c                       <== NOT EXECUTED
   23068:	1203300f 	andne	r3, r3, #15                                 <== NOT EXECUTED
        else                                                          
            vol->afat = 0;                                            
   2306c:	e5c43050 	strb	r3, [r4, #80]	; 0x50                         <== NOT EXECUTED
                                                                      
        vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);    
   23070:	e5dd1035 	ldrb	r1, [sp, #53]	; 0x35                         <== NOT EXECUTED
   23074:	e5dd3034 	ldrb	r3, [sp, #52]	; 0x34                         <== NOT EXECUTED
   23078:	e1831401 	orr	r1, r3, r1, lsl #8                            <== NOT EXECUTED
        if( vol->info_sec == 0 )                                      
   2307c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
        if (vol->mirror)                                              
            vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
        else                                                          
            vol->afat = 0;                                            
                                                                      
        vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);    
   23080:	e1c413bc 	strh	r1, [r4, #60]	; 0x3c                         <== NOT EXECUTED
        if( vol->info_sec == 0 )                                      
   23084:	0a000014 	beq	230dc <fat_init_volume_info+0x3a4>            <== NOT EXECUTED
            rtems_disk_release(vol->dd);                              
            rtems_set_errno_and_return_minus_one( EINVAL );           
        }                                                             
        else                                                          
        {                                                             
            ret = _fat_block_read(mt_entry, vol->info_sec , 0,        
   23088:	e28d60a8 	add	r6, sp, #168	; 0xa8                           <== NOT EXECUTED
   2308c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   23090:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   23094:	e3a03004 	mov	r3, #4                                        <== NOT EXECUTED
   23098:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
   2309c:	ebffff01 	bl	22ca8 <_fat_block_read>                        <== NOT EXECUTED
                                  FAT_FSI_LEADSIG_SIZE, fs_info_sector);
            if ( ret < 0 )                                            
   230a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   230a4:	ba00001b 	blt	23118 <fat_init_volume_info+0x3e0>            <== NOT EXECUTED
            {                                                         
                rtems_disk_release(vol->dd);                          
                return -1;                                            
            }                                                         
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
   230a8:	e5dd20aa 	ldrb	r2, [sp, #170]	; 0xaa                        <== NOT EXECUTED
   230ac:	e5dd30a9 	ldrb	r3, [sp, #169]	; 0xa9                        <== NOT EXECUTED
   230b0:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
   230b4:	e5dd10a8 	ldrb	r1, [sp, #168]	; 0xa8                        <== NOT EXECUTED
   230b8:	e1822403 	orr	r2, r2, r3, lsl #8                            <== NOT EXECUTED
   230bc:	e5dd30ab 	ldrb	r3, [sp, #171]	; 0xab                        <== NOT EXECUTED
   230c0:	e1822001 	orr	r2, r2, r1                                    <== NOT EXECUTED
   230c4:	e1822c03 	orr	r2, r2, r3, lsl #24                           <== NOT EXECUTED
   230c8:	e59f3254 	ldr	r3, [pc, #596]	; 23324 <fat_init_volume_info+0x5ec><== NOT EXECUTED
   230cc:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   230d0:	0a000006 	beq	230f0 <fat_init_volume_info+0x3b8>            <== NOT EXECUTED
int                                                                   
_fat_block_release(                                                   
    rtems_filesystem_mount_table_entry_t *mt_entry)                   
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    return fat_buf_release(fs_info);                                  
   230d4:	e5950034 	ldr	r0, [r5, #52]	; 0x34                          <== NOT EXECUTED
   230d8:	ebfffd71 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
                FAT_FSINFO_LEAD_SIGNATURE_VALUE)                      
            {                                                         
                _fat_block_release(mt_entry);                         
                rtems_disk_release(vol->dd);                          
   230dc:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   230e0:	ebff8ce9 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EINVAL );       
   230e4:	eb006785 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   230e8:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   230ec:	ea000083 	b	23300 <fat_init_volume_info+0x5c8>              <== NOT EXECUTED
            }                                                         
            else                                                      
            {                                                         
                ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
   230f0:	e1d413bc 	ldrh	r1, [r4, #60]	; 0x3c                         <== NOT EXECUTED
   230f4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   230f8:	e3a02f79 	mov	r2, #484	; 0x1e4                              <== NOT EXECUTED
   230fc:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   23100:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
   23104:	ebfffee7 	bl	22ca8 <_fat_block_read>                        <== NOT EXECUTED
                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
                if ( ret < 0 )                                        
   23108:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   2310c:	aa000004 	bge	23124 <fat_init_volume_info+0x3ec>            <== NOT EXECUTED
int                                                                   
_fat_block_release(                                                   
    rtems_filesystem_mount_table_entry_t *mt_entry)                   
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    return fat_buf_release(fs_info);                                  
   23110:	e5950034 	ldr	r0, [r5, #52]	; 0x34                          <== NOT EXECUTED
   23114:	ebfffd62 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
                ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
                if ( ret < 0 )                                        
                {                                                     
                    _fat_block_release(mt_entry);                     
                    rtems_disk_release(vol->dd);                      
   23118:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   2311c:	ebff8cda 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
   23120:	ea000077 	b	23304 <fat_init_volume_info+0x5cc>              <== NOT EXECUTED
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
   23124:	e5dd30ae 	ldrb	r3, [sp, #174]	; 0xae                        <== NOT EXECUTED
   23128:	e5dd20ad 	ldrb	r2, [sp, #173]	; 0xad                        <== NOT EXECUTED
   2312c:	e5dd10ac 	ldrb	r1, [sp, #172]	; 0xac                        <== NOT EXECUTED
   23130:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
   23134:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
   23138:	e5dd20af 	ldrb	r2, [sp, #175]	; 0xaf                        <== NOT EXECUTED
   2313c:	e1833001 	orr	r3, r3, r1                                    <== NOT EXECUTED
   23140:	e1833c02 	orr	r3, r3, r2, lsl #24                           <== NOT EXECUTED
   23144:	e5843040 	str	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
                vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
   23148:	e5dd30b2 	ldrb	r3, [sp, #178]	; 0xb2                        <== NOT EXECUTED
   2314c:	e5dd20b1 	ldrb	r2, [sp, #177]	; 0xb1                        <== NOT EXECUTED
   23150:	e5dd10b0 	ldrb	r1, [sp, #176]	; 0xb0                        <== NOT EXECUTED
   23154:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
   23158:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
   2315c:	e5dd20b3 	ldrb	r2, [sp, #179]	; 0xb3                        <== NOT EXECUTED
   23160:	e1833001 	orr	r3, r3, r1                                    <== NOT EXECUTED
   23164:	e1833c02 	orr	r3, r3, r2, lsl #24                           <== NOT EXECUTED
                rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
   23168:	e3e01000 	mvn	r1, #0                                        <== NOT EXECUTED
                    rtems_disk_release(vol->dd);                      
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
                vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
   2316c:	e5843044 	str	r3, [r4, #68]	; 0x44                          <== NOT EXECUTED
                rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
   23170:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   23174:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   23178:	ebfffe3b 	bl	22a6c <fat_fat32_update_fsinfo_sector>         <== NOT EXECUTED
                                                    0xFFFFFFFF);      
                if ( rc != RC_OK )                                    
   2317c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   23180:	0a00000b 	beq	231b4 <fat_init_volume_info+0x47c>            <== NOT EXECUTED
int                                                                   
_fat_block_release(                                                   
    rtems_filesystem_mount_table_entry_t *mt_entry)                   
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    return fat_buf_release(fs_info);                                  
   23184:	e5950034 	ldr	r0, [r5, #52]	; 0x34                          <== NOT EXECUTED
   23188:	ebfffd45 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
                rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
                                                    0xFFFFFFFF);      
                if ( rc != RC_OK )                                    
                {                                                     
                    _fat_block_release(mt_entry);                     
                    rtems_disk_release(vol->dd);                      
   2318c:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   23190:	ebff8cbd 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
                    return rc;                                        
   23194:	ea00005b 	b	23308 <fat_init_volume_info+0x5d0>              <== NOT EXECUTED
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
   23198:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
        vol->mirror = 0;                                              
        vol->afat = 0;                                                
        vol->free_cls = 0xFFFFFFFF;                                   
   2319c:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
    }                                                                 
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
        vol->mirror = 0;                                              
        vol->afat = 0;                                                
   231a0:	e5c43050 	strb	r3, [r4, #80]	; 0x50                         <== NOT EXECUTED
        vol->free_cls = 0xFFFFFFFF;                                   
        vol->next_cl = 0xFFFFFFFF;                                    
   231a4:	e5842044 	str	r2, [r4, #68]	; 0x44                          <== NOT EXECUTED
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
   231a8:	e5843038 	str	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
        vol->mirror = 0;                                              
   231ac:	e5c43048 	strb	r3, [r4, #72]	; 0x48                         <== NOT EXECUTED
        vol->afat = 0;                                                
        vol->free_cls = 0xFFFFFFFF;                                   
   231b0:	e5842040 	str	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
int                                                                   
_fat_block_release(                                                   
    rtems_filesystem_mount_table_entry_t *mt_entry)                   
{                                                                     
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    return fat_buf_release(fs_info);                                  
   231b4:	e5950034 	ldr	r0, [r5, #52]	; 0x34                          <== NOT EXECUTED
   231b8:	ebfffd39 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
        vol->next_cl = 0xFFFFFFFF;                                    
    }                                                                 
                                                                      
    _fat_block_release(mt_entry);                                     
                                                                      
    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;       
   231bc:	e5d41050 	ldrb	r1, [r4, #80]	; 0x50                         <== NOT EXECUTED
   231c0:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
   231c4:	e1d421b4 	ldrh	r2, [r4, #20]                                <== NOT EXECUTED
   231c8:	e0232190 	mla	r3, r0, r1, r2                                <== NOT EXECUTED
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
   231cc:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
        vol->next_cl = 0xFFFFFFFF;                                    
    }                                                                 
                                                                      
    _fat_block_release(mt_entry);                                     
                                                                      
    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;       
   231d0:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
   231d4:	e3a0100c 	mov	r1, #12                                       <== NOT EXECUTED
   231d8:	ebff8fc5 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if ( fs_info->vhash == NULL )                                     
   231dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    _fat_block_release(mt_entry);                                     
                                                                      
    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;       
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
   231e0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   231e4:	e5840064 	str	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
    if ( fs_info->vhash == NULL )                                     
   231e8:	0a000010 	beq	23230 <fat_init_volume_info+0x4f8>            <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
        rtems_chain_initialize_empty(fs_info->vhash + i);             
   231ec:	e280200c 	add	r2, r0, #12                                   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   231f0:	e280c004 	add	ip, r0, #4                                    <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
   231f4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   231f8:	e280e010 	add	lr, r0, #16                                   <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
   231fc:	e5835004 	str	r5, [r3, #4]                                  <== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);                 
   23200:	e5833008 	str	r3, [r3, #8]                                  <== NOT EXECUTED
                                                                      
    fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
   23204:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
   23208:	e3a0100c 	mov	r1, #12                                       <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   2320c:	e583e00c 	str	lr, [r3, #12]                                 <== NOT EXECUTED
   23210:	e583c000 	str	ip, [r3]                                      <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   23214:	e5822008 	str	r2, [r2, #8]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
   23218:	e5825004 	str	r5, [r2, #4]                                  <== NOT EXECUTED
   2321c:	ebff8fb4 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if ( fs_info->rhash == NULL )                                     
   23220:	e1500005 	cmp	r0, r5                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
        rtems_chain_initialize_empty(fs_info->vhash + i);             
                                                                      
    fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
   23224:	e5840068 	str	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
    if ( fs_info->rhash == NULL )                                     
   23228:	1a000003 	bne	2323c <fat_init_volume_info+0x504>            <== NOT EXECUTED
   2322c:	ea000018 	b	23294 <fat_init_volume_info+0x55c>              <== NOT EXECUTED
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
    if ( fs_info->vhash == NULL )                                     
    {                                                                 
        rtems_disk_release(vol->dd);                                  
   23230:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   23234:	ebff8c94 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
   23238:	ea00002e 	b	232f8 <fat_init_volume_info+0x5c0>              <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        free(fs_info->vhash);                                         
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
        rtems_chain_initialize_empty(fs_info->rhash + i);             
   2323c:	e280300c 	add	r3, r0, #12                                   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   23240:	e2802004 	add	r2, r0, #4                                    <== NOT EXECUTED
   23244:	e2801010 	add	r1, r0, #16                                   <== NOT EXECUTED
   23248:	e580100c 	str	r1, [r0, #12]                                 <== NOT EXECUTED
   2324c:	e8800024 	stm	r0, {r2, r5}                                  <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   23250:	e5800008 	str	r0, [r0, #8]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
   23254:	e5835004 	str	r5, [r3, #4]                                  <== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);                 
   23258:	e5833008 	str	r3, [r3, #8]                                  <== NOT EXECUTED
                                                                      
    fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;                
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
   2325c:	e594202c 	ldr	r2, [r4, #44]	; 0x2c                          <== NOT EXECUTED
   23260:	e5d43003 	ldrb	r3, [r4, #3]                                 <== NOT EXECUTED
   23264:	e1a03312 	lsl	r3, r2, r3                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
        rtems_chain_initialize_empty(fs_info->rhash + i);             
                                                                      
    fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;                
   23268:	e3a00c01 	mov	r0, #256	; 0x100                              <== NOT EXECUTED
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
   2326c:	e1a03203 	lsl	r3, r3, #4                                    <== NOT EXECUTED
   23270:	e5843078 	str	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
        rtems_chain_initialize_empty(fs_info->rhash + i);             
                                                                      
    fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;                
   23274:	e5840074 	str	r0, [r4, #116]	; 0x74                         <== NOT EXECUTED
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
    fs_info->index = 0;                                               
   23278:	e5845070 	str	r5, [r4, #112]	; 0x70                         <== NOT EXECUTED
    fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
   2327c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   23280:	ebff8f9b 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if ( fs_info->uino == NULL )                                      
   23284:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        rtems_chain_initialize_empty(fs_info->rhash + i);             
                                                                      
    fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;                
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
    fs_info->index = 0;                                               
    fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
   23288:	e584006c 	str	r0, [r4, #108]	; 0x6c                         <== NOT EXECUTED
    if ( fs_info->uino == NULL )                                      
   2328c:	1a00000a 	bne	232bc <fat_init_volume_info+0x584>            <== NOT EXECUTED
   23290:	ea000003 	b	232a4 <fat_init_volume_info+0x56c>              <== NOT EXECUTED
        rtems_chain_initialize_empty(fs_info->vhash + i);             
                                                                      
    fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
    if ( fs_info->rhash == NULL )                                     
    {                                                                 
        rtems_disk_release(vol->dd);                                  
   23294:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   23298:	ebff8c7b 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
        free(fs_info->vhash);                                         
   2329c:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
   232a0:	ea000013 	b	232f4 <fat_init_volume_info+0x5bc>              <== NOT EXECUTED
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
    fs_info->index = 0;                                               
    fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
    if ( fs_info->uino == NULL )                                      
    {                                                                 
        rtems_disk_release(vol->dd);                                  
   232a4:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   232a8:	ebff8c77 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
        free(fs_info->vhash);                                         
   232ac:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
   232b0:	ebff90ff 	bl	76b4 <free>                                    <== NOT EXECUTED
        free(fs_info->rhash);                                         
   232b4:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
   232b8:	ea00000d 	b	232f4 <fat_init_volume_info+0x5bc>              <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));  
   232bc:	e1d400b0 	ldrh	r0, [r4]                                     <== NOT EXECUTED
   232c0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   232c4:	ebff8f8a 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if (fs_info->sec_buf == NULL)                                     
   232c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        rtems_disk_release(vol->dd);                                  
        free(fs_info->vhash);                                         
        free(fs_info->rhash);                                         
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));  
   232cc:	e5840088 	str	r0, [r4, #136]	; 0x88                         <== NOT EXECUTED
    if (fs_info->sec_buf == NULL)                                     
   232d0:	11a07005 	movne	r7, r5                                      <== NOT EXECUTED
   232d4:	1a00000b 	bne	23308 <fat_init_volume_info+0x5d0>            <== NOT EXECUTED
    {                                                                 
        rtems_disk_release(vol->dd);                                  
   232d8:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   232dc:	ebff8c6a 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
        free(fs_info->vhash);                                         
   232e0:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
   232e4:	ebff90f2 	bl	76b4 <free>                                    <== NOT EXECUTED
        free(fs_info->rhash);                                         
   232e8:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
   232ec:	ebff90f0 	bl	76b4 <free>                                    <== NOT EXECUTED
        free(fs_info->uino);                                          
   232f0:	e594006c 	ldr	r0, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   232f4:	ebff90ee 	bl	76b4 <free>                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
   232f8:	eb006700 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   232fc:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   23300:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   23304:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
   23308:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   2330c:	e28dd0b8 	add	sp, sp, #184	; 0xb8                           <== NOT EXECUTED
   23310:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000225d4 <fat_ino_is_unique>: inline bool fat_ino_is_unique( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t ino ) {
   225d4:	e5903034 	ldr	r3, [r0, #52]	; 0x34                          <== NOT EXECUTED
   225d8:	e5930078 	ldr	r0, [r3, #120]	; 0x78                         <== NOT EXECUTED
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
   225dc:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
   225e0:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
   225e4:	23a00001 	movcs	r0, #1                                      <== NOT EXECUTED
   225e8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0003953c <fat_scan_fat_for_free_clusters>: uint32_t *chain, uint32_t count, uint32_t *cls_added, uint32_t *last_cl ) {
   3953c:	e92d4fff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   39540:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t                             *chain,                      
    uint32_t                              count,                      
    uint32_t                             *cls_added,                  
    uint32_t                             *last_cl                     
    )                                                                 
{                                                                     
   39544:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
    uint32_t       save_cln = 0;                                      
    uint32_t       data_cls_val = fs_info->vol.data_cls + 2;          
   39548:	e5940034 	ldr	r0, [r4, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t       i = 2;                                             
                                                                      
    *cls_added = 0;                                                   
                                                                      
    if (count == 0)                                                   
   3954c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
   39550:	e3a09000 	mov	r9, #0                                        <== NOT EXECUTED
    uint32_t       save_cln = 0;                                      
    uint32_t       data_cls_val = fs_info->vol.data_cls + 2;          
   39554:	e2800002 	add	r0, r0, #2                                    <== NOT EXECUTED
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
   39558:	e58d900c 	str	r9, [sp, #12]                                 <== NOT EXECUTED
    uint32_t                             *chain,                      
    uint32_t                              count,                      
    uint32_t                             *cls_added,                  
    uint32_t                             *last_cl                     
    )                                                                 
{                                                                     
   3955c:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
    uint32_t       data_cls_val = fs_info->vol.data_cls + 2;          
    uint32_t       i = 2;                                             
                                                                      
    *cls_added = 0;                                                   
                                                                      
    if (count == 0)                                                   
   39560:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
    uint32_t                             *chain,                      
    uint32_t                              count,                      
    uint32_t                             *cls_added,                  
    uint32_t                             *last_cl                     
    )                                                                 
{                                                                     
   39564:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
    uint32_t       save_cln = 0;                                      
    uint32_t       data_cls_val = fs_info->vol.data_cls + 2;          
   39568:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
    uint32_t       i = 2;                                             
                                                                      
    *cls_added = 0;                                                   
   3956c:	e5839000 	str	r9, [r3]                                      <== NOT EXECUTED
                                                                      
    if (count == 0)                                                   
   39570:	01a07002 	moveq	r7, r2                                      <== NOT EXECUTED
   39574:	0a000058 	beq	396dc <fat_scan_fat_for_free_clusters+0x1a0>  <== NOT EXECUTED
        return rc;                                                    
                                                                      
    if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)                  
   39578:	e5946044 	ldr	r6, [r4, #68]	; 0x44                          <== NOT EXECUTED
   3957c:	e3760001 	cmn	r6, #1                                        <== NOT EXECUTED
   39580:	03a06002 	moveq	r6, #2                                      <== NOT EXECUTED
   39584:	e3a0b002 	mov	fp, #2                                        <== NOT EXECUTED
   39588:	ea000042 	b	39698 <fat_scan_fat_for_free_clusters+0x15c>    <== NOT EXECUTED
     * starting at cluster 2, so the maximum valid cluster number is  
     * (fs_info->vol.data_cls + 1)                                    
     */                                                               
    while (i < data_cls_val)                                          
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);       
   3958c:	ebffff61 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   39590:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   39594:	0a000004 	beq	395ac <fat_scan_fat_for_free_clusters+0x70>   <== NOT EXECUTED
        {                                                             
            if (*cls_added != 0)                                      
   39598:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
   3959c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                fat_free_fat_clusters_chain(mt_entry, (*chain));      
   395a0:	11a00005 	movne	r0, r5                                      <== NOT EXECUTED
    while (i < data_cls_val)                                          
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);       
        if ( rc != RC_OK )                                            
        {                                                             
            if (*cls_added != 0)                                      
   395a4:	0a00004c 	beq	396dc <fat_scan_fat_for_free_clusters+0x1a0>  <== NOT EXECUTED
   395a8:	ea000015 	b	39604 <fat_scan_fat_for_free_clusters+0xc8>     <== NOT EXECUTED
                fat_free_fat_clusters_chain(mt_entry, (*chain));      
            return rc;                                                
        }                                                             
                                                                      
        if (next_cln == FAT_GENFAT_FREE)                              
   395ac:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   395b0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   395b4:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
   395b8:	1a000031 	bne	39684 <fat_scan_fat_for_free_clusters+0x148>  <== NOT EXECUTED
            /*                                                        
             * We are enforced to process allocation of the first free cluster
             * by separate 'if' statement because otherwise undo function
             * wouldn't work properly                                 
             */                                                       
            if (*cls_added == 0)                                      
   395bc:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
   395c0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                /* set EOC value to new allocated cluster */          
                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
   395c4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   395c8:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
             * wouldn't work properly                                 
             */                                                       
            if (*cls_added == 0)                                      
            {                                                         
                *chain = cl4find;                                     
                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
   395cc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
            /*                                                        
             * We are enforced to process allocation of the first free cluster
             * by separate 'if' statement because otherwise undo function
             * wouldn't work properly                                 
             */                                                       
            if (*cls_added == 0)                                      
   395d0:	1a000004 	bne	395e8 <fat_scan_fat_for_free_clusters+0xac>   <== NOT EXECUTED
            {                                                         
                *chain = cl4find;                                     
   395d4:	e58a6000 	str	r6, [sl]                                      <== NOT EXECUTED
                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
   395d8:	ebfffeb6 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
                if ( rc != RC_OK )                                    
   395dc:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   395e0:	0a000017 	beq	39644 <fat_scan_fat_for_free_clusters+0x108>  <== NOT EXECUTED
   395e4:	ea00003c 	b	396dc <fat_scan_fat_for_free_clusters+0x1a0>    <== NOT EXECUTED
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                /* set EOC value to new allocated cluster */          
                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
   395e8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   395ec:	ebfffeb1 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
                if ( rc != RC_OK )                                    
   395f0:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(mt_entry, (*chain));  
                    return rc;                                        
                }                                                     
                                                                      
                rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
   395f4:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   395f8:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   395fc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
            }                                                         
            else                                                      
            {                                                         
                /* set EOC value to new allocated cluster */          
                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
                if ( rc != RC_OK )                                    
   39600:	0a000002 	beq	39610 <fat_scan_fat_for_free_clusters+0xd4>   <== NOT EXECUTED
                {                                                     
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(mt_entry, (*chain));  
   39604:	e59a1000 	ldr	r1, [sl]                                      <== NOT EXECUTED
   39608:	ebffff9c 	bl	39480 <fat_free_fat_clusters_chain>            <== NOT EXECUTED
                    return rc;                                        
   3960c:	ea000032 	b	396dc <fat_scan_fat_for_free_clusters+0x1a0>    <== NOT EXECUTED
                }                                                     
                                                                      
                rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
   39610:	ebfffea8 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
                if ( rc != RC_OK )                                    
   39614:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   39618:	0a000009 	beq	39644 <fat_scan_fat_for_free_clusters+0x108>  <== NOT EXECUTED
                {                                                     
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(mt_entry, (*chain));  
   3961c:	e59a1000 	ldr	r1, [sl]                                      <== NOT EXECUTED
   39620:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   39624:	ebffff95 	bl	39480 <fat_free_fat_clusters_chain>            <== NOT EXECUTED
                    /* trying to save last allocated cluster for future use */
                    fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
   39628:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3962c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   39630:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   39634:	ebfffe9f 	bl	390b8 <fat_set_fat_cluster>                    <== NOT EXECUTED
                    fat_buf_release(fs_info);                         
   39638:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3963c:	ebffa418 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
                    return rc;                                        
   39640:	ea000025 	b	396dc <fat_scan_fat_for_free_clusters+0x1a0>    <== NOT EXECUTED
                }                                                     
            }                                                         
                                                                      
            save_cln = cl4find;                                       
            (*cls_added)++;                                           
   39644:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
   39648:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            save_cln = cl4find;                                       
            (*cls_added)++;                                           
   3964c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
   39650:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            save_cln = cl4find;                                       
            (*cls_added)++;                                           
   39654:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
   39658:	1a000008 	bne	39680 <fat_scan_fat_for_free_clusters+0x144>  <== NOT EXECUTED
            {                                                         
                    fs_info->vol.next_cl = save_cln;                  
                    if (fs_info->vol.free_cls != 0xFFFFFFFF)          
   3965c:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
            (*cls_added)++;                                           
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
            {                                                         
                    fs_info->vol.next_cl = save_cln;                  
   39660:	e5846044 	str	r6, [r4, #68]	; 0x44                          <== NOT EXECUTED
                    if (fs_info->vol.free_cls != 0xFFFFFFFF)          
   39664:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
                        fs_info->vol.free_cls -= (*cls_added);        
   39668:	15982000 	ldrne	r2, [r8]                                    <== NOT EXECUTED
   3966c:	10623003 	rsbne	r3, r2, r3                                  <== NOT EXECUTED
   39670:	15843040 	strne	r3, [r4, #64]	; 0x40                        <== NOT EXECUTED
                *last_cl = save_cln;                                  
   39674:	e59d3034 	ldr	r3, [sp, #52]	; 0x34                          <== NOT EXECUTED
   39678:	e5836000 	str	r6, [r3]                                      <== NOT EXECUTED
   3967c:	ea000013 	b	396d0 <fat_scan_fat_for_free_clusters+0x194>    <== NOT EXECUTED
                fat_buf_release(fs_info);                             
                return rc;                                            
   39680:	e1a09006 	mov	r9, r6                                        <== NOT EXECUTED
            }                                                         
        }                                                             
        i++;                                                          
        cl4find++;                                                    
        if (cl4find >= data_cls_val)                                  
   39684:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
                fat_buf_release(fs_info);                             
                return rc;                                            
            }                                                         
        }                                                             
        i++;                                                          
        cl4find++;                                                    
   39688:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
        if (cl4find >= data_cls_val)                                  
   3968c:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
   39690:	23a06002 	movcs	r6, #2                                      <== NOT EXECUTED
                *last_cl = save_cln;                                  
                fat_buf_release(fs_info);                             
                return rc;                                            
            }                                                         
        }                                                             
        i++;                                                          
   39694:	e28bb001 	add	fp, fp, #1                                    <== NOT EXECUTED
    /*                                                                
     * fs_info->vol.data_cls is exactly the count of data clusters    
     * starting at cluster 2, so the maximum valid cluster number is  
     * (fs_info->vol.data_cls + 1)                                    
     */                                                               
    while (i < data_cls_val)                                          
   39698:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   3969c:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
    {                                                                 
        rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);       
   396a0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   396a4:	e28d200c 	add	r2, sp, #12                                   <== NOT EXECUTED
   396a8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    /*                                                                
     * fs_info->vol.data_cls is exactly the count of data clusters    
     * starting at cluster 2, so the maximum valid cluster number is  
     * (fs_info->vol.data_cls + 1)                                    
     */                                                               
    while (i < data_cls_val)                                          
   396ac:	3affffb6 	bcc	3958c <fat_scan_fat_for_free_clusters+0x50>   <== NOT EXECUTED
        if (cl4find >= data_cls_val)                                  
            cl4find = 2;                                              
    }                                                                 
                                                                      
        fs_info->vol.next_cl = save_cln;                              
        if (fs_info->vol.free_cls != 0xFFFFFFFF)                      
   396b0:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
        cl4find++;                                                    
        if (cl4find >= data_cls_val)                                  
            cl4find = 2;                                              
    }                                                                 
                                                                      
        fs_info->vol.next_cl = save_cln;                              
   396b4:	e5849044 	str	r9, [r4, #68]	; 0x44                          <== NOT EXECUTED
        if (fs_info->vol.free_cls != 0xFFFFFFFF)                      
   396b8:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
            fs_info->vol.free_cls -= (*cls_added);                    
   396bc:	15982000 	ldrne	r2, [r8]                                    <== NOT EXECUTED
   396c0:	10623003 	rsbne	r3, r2, r3                                  <== NOT EXECUTED
                                                                      
    *last_cl = save_cln;                                              
   396c4:	e59d2034 	ldr	r2, [sp, #52]	; 0x34                          <== NOT EXECUTED
            cl4find = 2;                                              
    }                                                                 
                                                                      
        fs_info->vol.next_cl = save_cln;                              
        if (fs_info->vol.free_cls != 0xFFFFFFFF)                      
            fs_info->vol.free_cls -= (*cls_added);                    
   396c8:	15843040 	strne	r3, [r4, #64]	; 0x40                        <== NOT EXECUTED
                                                                      
    *last_cl = save_cln;                                              
   396cc:	e5829000 	str	r9, [r2]                                      <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
   396d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   396d4:	ebffa3f2 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
   396d8:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   396dc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   396e0:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   396e4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

000390b8 <fat_set_fat_cluster>: fat_set_fat_cluster( rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t cln, uint32_t in_val ) {
   390b8:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
    uint32_t            sec = 0;                                      
    uint32_t            ofs = 0;                                      
    uint16_t            fat16_clv = 0;                                
    uint32_t            fat32_clv = 0;                                
    rtems_bdbuf_buffer *block0 = NULL;                                
   390bc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
   390c0:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
fat_set_fat_cluster(                                                  
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    uint32_t                              in_val                      
    )                                                                 
{                                                                     
   390c4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
    uint32_t            sec = 0;                                      
    uint32_t            ofs = 0;                                      
    uint16_t            fat16_clv = 0;                                
    uint32_t            fat32_clv = 0;                                
    rtems_bdbuf_buffer *block0 = NULL;                                
   390c8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
fat_set_fat_cluster(                                                  
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    uint32_t                              in_val                      
    )                                                                 
{                                                                     
   390cc:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
    int                 rc = RC_OK;                                   
    fat_fs_info_t      *fs_info = mt_entry->fs_info;                  
   390d0:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint16_t            fat16_clv = 0;                                
    uint32_t            fat32_clv = 0;                                
    rtems_bdbuf_buffer *block0 = NULL;                                
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
   390d4:	9a00008a 	bls	39304 <fat_set_fat_cluster+0x24c>             <== NOT EXECUTED
   390d8:	e5943034 	ldr	r3, [r4, #52]	; 0x34                          <== NOT EXECUTED
   390dc:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   390e0:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
   390e4:	8a000086 	bhi	39304 <fat_set_fat_cluster+0x24c>             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
   390e8:	e5d4300a 	ldrb	r3, [r4, #10]                                <== NOT EXECUTED
   390ec:	e2130001 	ands	r0, r3, #1                                   <== NOT EXECUTED
   390f0:	108120a1 	addne	r2, r1, r1, lsr #1                          <== NOT EXECUTED
   390f4:	1a000002 	bne	39104 <fat_set_fat_cluster+0x4c>              <== NOT EXECUTED
   390f8:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
   390fc:	11a02081 	lslne	r2, r1, #1                                  <== NOT EXECUTED
   39100:	01a02101 	lsleq	r2, r1, #2                                  <== NOT EXECUTED
   39104:	e5d4a002 	ldrb	sl, [r4, #2]                                 <== NOT EXECUTED
   39108:	e594104c 	ldr	r1, [r4, #76]	; 0x4c                          <== NOT EXECUTED
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   3910c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
   39110:	e081aa32 	add	sl, r1, r2, lsr sl                            <== NOT EXECUTED
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   39114:	108580a5 	addne	r8, r5, r5, lsr #1                          <== NOT EXECUTED
   39118:	1a000002 	bne	39128 <fat_set_fat_cluster+0x70>              <== NOT EXECUTED
   3911c:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
   39120:	11a08085 	lslne	r8, r5, #1                                  <== NOT EXECUTED
   39124:	01a08105 	lsleq	r8, r5, #2                                  <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
   39128:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3912c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   39130:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   39134:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   39138:	e1d4b0b0 	ldrh	fp, [r4]                                     <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
   3913c:	ebffa5a8 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   39140:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
   39144:	e1a0900d 	mov	r9, sp                                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   39148:	1a000071 	bne	39314 <fat_set_fat_cluster+0x25c>             <== NOT EXECUTED
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
   3914c:	e5d4600a 	ldrb	r6, [r4, #10]                                <== NOT EXECUTED
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   39150:	e24bb001 	sub	fp, fp, #1                                    <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
   39154:	e3560002 	cmp	r6, #2                                        <== NOT EXECUTED
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
   39158:	e008800b 	and	r8, r8, fp                                    <== NOT EXECUTED
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);     
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
   3915c:	0a00005a 	beq	392cc <fat_set_fat_cluster+0x214>             <== NOT EXECUTED
   39160:	e3560004 	cmp	r6, #4                                        <== NOT EXECUTED
   39164:	0a00005c 	beq	392dc <fat_set_fat_cluster+0x224>             <== NOT EXECUTED
   39168:	e3560001 	cmp	r6, #1                                        <== NOT EXECUTED
   3916c:	1a000064 	bne	39304 <fat_set_fat_cluster+0x24c>             <== NOT EXECUTED
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
   39170:	e3150001 	tst	r5, #1                                        <== NOT EXECUTED
   39174:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39178:	0a000026 	beq	39218 <fat_set_fat_cluster+0x160>             <== NOT EXECUTED
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
                *((uint8_t   *)(block0->buffer + ofs)) =              
                        (*((uint8_t   *)(block0->buffer + ofs))) & 0x0F;
   3917c:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
                *((uint8_t   *)(block0->buffer + ofs)) =              
   39180:	e7d32008 	ldrb	r2, [r3, r8]                                 <== NOT EXECUTED
   39184:	e202200f 	and	r2, r2, #15                                   <== NOT EXECUTED
   39188:	e7c32008 	strb	r2, [r3, r8]                                 <== NOT EXECUTED
                        (*((uint8_t   *)(block0->buffer + ofs))) & 0x0F;
                                                                      
                *((uint8_t   *)(block0->buffer + ofs)) =              
                        (*((uint8_t   *)(block0->buffer + ofs))) |    
   3918c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39190:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
                *((uint8_t   *)(block0->buffer + ofs)) =              
                        (*((uint8_t   *)(block0->buffer + ofs))) & 0x0F;
                                                                      
                *((uint8_t   *)(block0->buffer + ofs)) =              
   39194:	e7d32008 	ldrb	r2, [r3, r8]                                 <== NOT EXECUTED
    switch ( fs_info->vol.type )                                      
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
   39198:	e1a07a07 	lsl	r7, r7, #20                                   <== NOT EXECUTED
                *((uint8_t   *)(block0->buffer + ofs)) =              
                        (*((uint8_t   *)(block0->buffer + ofs))) & 0x0F;
                                                                      
                *((uint8_t   *)(block0->buffer + ofs)) =              
   3919c:	e1822827 	orr	r2, r2, r7, lsr #16                           <== NOT EXECUTED
   391a0:	e7c32008 	strb	r2, [r3, r8]                                 <== NOT EXECUTED
                        (*((uint8_t   *)(block0->buffer + ofs))) |    
                        (uint8_t  )(fat16_clv & 0x00FF);              
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
   391a4:	e1d430b0 	ldrh	r3, [r4]                                     <== NOT EXECUTED
   391a8:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   391ac:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
   391b0:	e5c46080 	strb	r6, [r4, #128]	; 0x80                        <== NOT EXECUTED
   391b4:	1a00000e 	bne	391f4 <fat_set_fat_cluster+0x13c>             <== NOT EXECUTED
                {                                                     
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
   391b8:	e28a1001 	add	r1, sl, #1                                    <== NOT EXECUTED
   391bc:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   391c0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   391c4:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   391c8:	ebffa585 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
                                        &block0);                     
                    if (rc != RC_OK)                                  
   391cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   391d0:	1a00004f 	bne	39314 <fat_set_fat_cluster+0x25c>             <== NOT EXECUTED
                        return rc;                                    
                                                                      
                     *((uint8_t   *)(block0->buffer)) &= 0x00;        
   391d4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   391d8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   391dc:	e5c30000 	strb	r0, [r3]                                     <== NOT EXECUTED
                                                                      
                     *((uint8_t   *)(block0->buffer)) =               
                            (*((uint8_t   *)(block0->buffer))) |      
   391e0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   391e4:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                    if (rc != RC_OK)                                  
                        return rc;                                    
                                                                      
                     *((uint8_t   *)(block0->buffer)) &= 0x00;        
                                                                      
                     *((uint8_t   *)(block0->buffer)) =               
   391e8:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
   391ec:	e1827c27 	orr	r7, r2, r7, lsr #24                           <== NOT EXECUTED
   391f0:	ea000026 	b	39290 <fat_set_fat_cluster+0x1d8>               <== NOT EXECUTED
                                                                      
                     fat_buf_mark_modified(fs_info);                  
                }                                                     
                else                                                  
                {                                                     
                    *((uint8_t   *)(block0->buffer + ofs + 1)) &= 0x00;
   391f4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   391f8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   391fc:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   39200:	e7c30008 	strb	r0, [r3, r8]                                 <== NOT EXECUTED
                                                                      
                    *((uint8_t   *)(block0->buffer + ofs + 1)) =      
                            (*((uint8_t   *)(block0->buffer + ofs + 1))) |
   39204:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39208:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                }                                                     
                else                                                  
                {                                                     
                    *((uint8_t   *)(block0->buffer + ofs + 1)) &= 0x00;
                                                                      
                    *((uint8_t   *)(block0->buffer + ofs + 1)) =      
   3920c:	e7d32008 	ldrb	r2, [r3, r8]                                 <== NOT EXECUTED
   39210:	e1827c27 	orr	r7, r2, r7, lsr #24                           <== NOT EXECUTED
   39214:	ea00002a 	b	392c4 <fat_set_fat_cluster+0x20c>               <== NOT EXECUTED
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;    
                *((uint8_t   *)(block0->buffer + ofs)) &= 0x00;       
   39218:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   3921c:	e7c30008 	strb	r0, [r3, r8]                                 <== NOT EXECUTED
                                                                      
                *((uint8_t   *)(block0->buffer + ofs)) =              
                        (*((uint8_t   *)(block0->buffer + ofs))) |    
   39220:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39224:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                            (uint8_t  )((fat16_clv & 0xFF00)>>8);     
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;    
   39228:	e1a07a07 	lsl	r7, r7, #20                                   <== NOT EXECUTED
                *((uint8_t   *)(block0->buffer + ofs)) &= 0x00;       
                                                                      
                *((uint8_t   *)(block0->buffer + ofs)) =              
   3922c:	e7d32008 	ldrb	r2, [r3, r8]                                 <== NOT EXECUTED
                            (uint8_t  )((fat16_clv & 0xFF00)>>8);     
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;    
   39230:	e1a07a27 	lsr	r7, r7, #20                                   <== NOT EXECUTED
                *((uint8_t   *)(block0->buffer + ofs)) &= 0x00;       
                                                                      
                *((uint8_t   *)(block0->buffer + ofs)) =              
   39234:	e1822007 	orr	r2, r2, r7                                    <== NOT EXECUTED
   39238:	e7c32008 	strb	r2, [r3, r8]                                 <== NOT EXECUTED
                        (*((uint8_t   *)(block0->buffer + ofs))) |    
                        (uint8_t  )(fat16_clv & 0x00FF);              
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
   3923c:	e1d430b0 	ldrh	r3, [r4]                                     <== NOT EXECUTED
   39240:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   39244:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
   39248:	e5c46080 	strb	r6, [r4, #128]	; 0x80                        <== NOT EXECUTED
   3924c:	1a000012 	bne	3929c <fat_set_fat_cluster+0x1e4>             <== NOT EXECUTED
                {                                                     
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
   39250:	e28a1001 	add	r1, sl, #1                                    <== NOT EXECUTED
   39254:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   39258:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3925c:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   39260:	ebffa55f 	bl	227e4 <fat_buf_access>                         <== NOT EXECUTED
                                        &block0);                     
                    if (rc != RC_OK)                                  
   39264:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   39268:	1a000029 	bne	39314 <fat_set_fat_cluster+0x25c>             <== NOT EXECUTED
                        return rc;                                    
                                                                      
                    *((uint8_t   *)(block0->buffer)) =                
                            (*((uint8_t   *)(block0->buffer))) & 0xF0;
   3926c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39270:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
                                        &block0);                     
                    if (rc != RC_OK)                                  
                        return rc;                                    
                                                                      
                    *((uint8_t   *)(block0->buffer)) =                
   39274:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
   39278:	e3c2200f 	bic	r2, r2, #15                                   <== NOT EXECUTED
   3927c:	e5c32000 	strb	r2, [r3]                                     <== NOT EXECUTED
                            (*((uint8_t   *)(block0->buffer))) & 0xF0;
                                                                      
                    *((uint8_t   *)(block0->buffer)) =                
                            (*((uint8_t   *)(block0->buffer))) |      
   39280:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   39284:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                        return rc;                                    
                                                                      
                    *((uint8_t   *)(block0->buffer)) =                
                            (*((uint8_t   *)(block0->buffer))) & 0xF0;
                                                                      
                    *((uint8_t   *)(block0->buffer)) =                
   39288:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
   3928c:	e1827427 	orr	r7, r2, r7, lsr #8                            <== NOT EXECUTED
   39290:	e5c37000 	strb	r7, [r3]                                     <== NOT EXECUTED
   39294:	e5c46080 	strb	r6, [r4, #128]	; 0x80                        <== NOT EXECUTED
   39298:	ea00001d 	b	39314 <fat_set_fat_cluster+0x25c>               <== NOT EXECUTED
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *((uint8_t   *)(block0->buffer + ofs + 1)) =      
                      (*((uint8_t   *)(block0->buffer + ofs + 1))) & 0xF0;
   3929c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   392a0:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   392a4:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *((uint8_t   *)(block0->buffer + ofs + 1)) =      
   392a8:	e7d32008 	ldrb	r2, [r3, r8]                                 <== NOT EXECUTED
   392ac:	e3c2200f 	bic	r2, r2, #15                                   <== NOT EXECUTED
   392b0:	e7c32008 	strb	r2, [r3, r8]                                 <== NOT EXECUTED
                      (*((uint8_t   *)(block0->buffer + ofs + 1))) & 0xF0;
                                                                      
                    *((uint8_t   *)(block0->buffer + ofs+1)) =        
                           (*((uint8_t   *)(block0->buffer + ofs+1))) |
   392b4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   392b8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                else                                                  
                {                                                     
                    *((uint8_t   *)(block0->buffer + ofs + 1)) =      
                      (*((uint8_t   *)(block0->buffer + ofs + 1))) & 0xF0;
                                                                      
                    *((uint8_t   *)(block0->buffer + ofs+1)) =        
   392bc:	e7d32008 	ldrb	r2, [r3, r8]                                 <== NOT EXECUTED
   392c0:	e1827427 	orr	r7, r2, r7, lsr #8                            <== NOT EXECUTED
   392c4:	e7c37008 	strb	r7, [r3, r8]                                 <== NOT EXECUTED
   392c8:	ea000011 	b	39314 <fat_set_fat_cluster+0x25c>               <== NOT EXECUTED
                }                                                     
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(block0->buffer + ofs)) =                 
   392cc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   392d0:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   392d4:	e18370b8 	strh	r7, [r3, r8]                                 <== NOT EXECUTED
   392d8:	ea000006 	b	392f8 <fat_set_fat_cluster+0x240>               <== NOT EXECUTED
                                                                      
        case FAT_FAT32:                                               
            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));           
                                                                      
            *((uint32_t   *)(block0->buffer + ofs)) =                 
            (*((uint32_t   *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
   392dc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   392e0:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));           
                                                                      
            *((uint32_t   *)(block0->buffer + ofs)) =                 
   392e4:	e7932008 	ldr	r2, [r3, r8]                                  <== NOT EXECUTED
            (*((uint32_t   *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
                                                                      
            *((uint32_t   *)(block0->buffer + ofs)) =                 
   392e8:	e3c7720f 	bic	r7, r7, #-268435456	; 0xf0000000              <== NOT EXECUTED
            break;                                                    
                                                                      
        case FAT_FAT32:                                               
            fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));           
                                                                      
            *((uint32_t   *)(block0->buffer + ofs)) =                 
   392ec:	e202220f 	and	r2, r2, #-268435456	; 0xf0000000              <== NOT EXECUTED
            (*((uint32_t   *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
                                                                      
            *((uint32_t   *)(block0->buffer + ofs)) =                 
   392f0:	e1827007 	orr	r7, r2, r7                                    <== NOT EXECUTED
   392f4:	e7837008 	str	r7, [r3, r8]                                  <== NOT EXECUTED
   392f8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   392fc:	e5c43080 	strb	r3, [r4, #128]	; 0x80                        <== NOT EXECUTED
   39300:	ea000003 	b	39314 <fat_set_fat_cluster+0x25c>               <== NOT EXECUTED
                                                                      
            fat_buf_mark_modified(fs_info);                           
            break;                                                    
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
   39304:	eb000efd 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   39308:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3930c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   39310:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
   39314:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

00022acc <fat_shutdown_drive>: * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry) {
   22acc:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
    int            rc = RC_OK;                                        
    fat_fs_info_t *fs_info = mt_entry->fs_info;                       
   22ad0:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    int            i = 0;                                             
                                                                      
    if (fs_info->vol.type & FAT_FAT32)                                
   22ad4:	e5d4500a 	ldrb	r5, [r4, #10]                                <== NOT EXECUTED
   22ad8:	e2155004 	ands	r5, r5, #4                                   <== NOT EXECUTED
   22adc:	0a000004 	beq	22af4 <fat_shutdown_drive+0x28>               <== NOT EXECUTED
    {                                                                 
        rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
   22ae0:	e2841040 	add	r1, r4, #64	; 0x40                            <== NOT EXECUTED
   22ae4:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
   22ae8:	ebffffdf 	bl	22a6c <fat_fat32_update_fsinfo_sector>         <== NOT EXECUTED
                                            fs_info->vol.next_cl);    
        if ( rc != RC_OK )                                            
   22aec:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   22af0:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
            rc = -1;                                                  
    }                                                                 
                                                                      
    fat_buf_release(fs_info);                                         
   22af4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   22af8:	ebfffee9 	bl	226a4 <fat_buf_release>                        <== NOT EXECUTED
                                                                      
    if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)    
   22afc:	e2841054 	add	r1, r4, #84	; 0x54                            <== NOT EXECUTED
   22b00:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   22b04:	ebff8315 	bl	3760 <rtems_bdbuf_syncdev>                     <== NOT EXECUTED
   22b08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22b0c:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
   22b10:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
        rc = -1;                                                      
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->vhash + i;          
   22b14:	e5948064 	ldr	r8, [r4, #100]	; 0x64                         <== NOT EXECUTED
   22b18:	e0888007 	add	r8, r8, r7                                    <== NOT EXECUTED
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
   22b1c:	ea000000 	b	22b24 <fat_shutdown_drive+0x58>                 <== NOT EXECUTED
            free(node);                                               
   22b20:	ebff92e3 	bl	76b4 <free>                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
   22b24:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   22b28:	ebffa64d 	bl	c464 <_Chain_Get>                              <== NOT EXECUTED
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->vhash + i;          
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
   22b2c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   22b30:	1afffffa 	bne	22b20 <fat_shutdown_drive+0x54>               <== NOT EXECUTED
   22b34:	e287700c 	add	r7, r7, #12                                   <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
                                                                      
    if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)    
        rc = -1;                                                      
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
   22b38:	e3570018 	cmp	r7, #24                                       <== NOT EXECUTED
   22b3c:	1afffff4 	bne	22b14 <fat_shutdown_drive+0x48>               <== NOT EXECUTED
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->rhash + i;          
   22b40:	e5947068 	ldr	r7, [r4, #104]	; 0x68                         <== NOT EXECUTED
   22b44:	e0877006 	add	r7, r7, r6                                    <== NOT EXECUTED
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
   22b48:	ea000000 	b	22b50 <fat_shutdown_drive+0x84>                 <== NOT EXECUTED
            free(node);                                               
   22b4c:	ebff92d8 	bl	76b4 <free>                                    <== NOT EXECUTED
   22b50:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   22b54:	ebffa642 	bl	c464 <_Chain_Get>                              <== NOT EXECUTED
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->rhash + i;          
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
   22b58:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   22b5c:	1afffffa 	bne	22b4c <fat_shutdown_drive+0x80>               <== NOT EXECUTED
   22b60:	e286600c 	add	r6, r6, #12                                   <== NOT EXECUTED
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
   22b64:	e3560018 	cmp	r6, #24                                       <== NOT EXECUTED
   22b68:	1afffff4 	bne	22b40 <fat_shutdown_drive+0x74>               <== NOT EXECUTED
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    free(fs_info->vhash);                                             
   22b6c:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
   22b70:	ebff92cf 	bl	76b4 <free>                                    <== NOT EXECUTED
    free(fs_info->rhash);                                             
   22b74:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
   22b78:	ebff92cd 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
    free(fs_info->uino);                                              
   22b7c:	e594006c 	ldr	r0, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   22b80:	ebff92cb 	bl	76b4 <free>                                    <== NOT EXECUTED
    free(fs_info->sec_buf);                                           
   22b84:	e5940088 	ldr	r0, [r4, #136]	; 0x88                         <== NOT EXECUTED
   22b88:	ebff92c9 	bl	76b4 <free>                                    <== NOT EXECUTED
    rtems_disk_release(fs_info->vol.dd);                              
   22b8c:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   22b90:	ebff8e3d 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
                                                                      
    if (rc)                                                           
   22b94:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   22b98:	0a000002 	beq	22ba8 <fat_shutdown_drive+0xdc>               <== NOT EXECUTED
        errno = EIO;                                                  
   22b9c:	eb0068d7 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   22ba0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   22ba4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   22ba8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   22bac:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00039a80 <fchdir>: #include <rtems/seterr.h> int fchdir( int fd ) {
   39a80:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_filesystem_location_info_t loc, saved;                        
                                                                      
  rtems_libio_check_fd( fd );                                         
   39a84:	e59f3148 	ldr	r3, [pc, #328]	; 39bd4 <fchdir+0x154>         <== NOT EXECUTED
   39a88:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   39a8c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int fchdir(                                                           
  int       fd                                                        
)                                                                     
{                                                                     
   39a90:	e24dd02c 	sub	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_filesystem_location_info_t loc, saved;                        
                                                                      
  rtems_libio_check_fd( fd );                                         
   39a94:	2a000005 	bcs	39ab0 <fchdir+0x30>                           <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
   39a98:	e59f3138 	ldr	r3, [pc, #312]	; 39bd8 <fchdir+0x158>         <== NOT EXECUTED
   39a9c:	e5934000 	ldr	r4, [r3]                                      <== NOT EXECUTED
   39aa0:	e0844300 	add	r4, r4, r0, lsl #6                            <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
   39aa4:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
   39aa8:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
   39aac:	1a000002 	bne	39abc <fchdir+0x3c>                           <== NOT EXECUTED
   39ab0:	eb000d12 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   39ab4:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   39ab8:	ea000011 	b	39b04 <fchdir+0x84>                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify you can change directory into this node.                  
   */                                                                 
                                                                      
  if ( !iop->pathinfo.ops ) {                                         
   39abc:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
   39ac0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   39ac4:	0a000002 	beq	39ad4 <fchdir+0x54>                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  if ( !iop->pathinfo.ops->node_type_h ) {                            
   39ac8:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
   39acc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   39ad0:	1a000002 	bne	39ae0 <fchdir+0x60>                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   39ad4:	eb000d09 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   39ad8:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   39adc:	ea000008 	b	39b04 <fchdir+0x84>                             <== NOT EXECUTED
  }                                                                   
                                                                      
  if (  (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=        
   39ae0:	e2844018 	add	r4, r4, #24                                   <== NOT EXECUTED
   39ae4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   39ae8:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   39aec:	e12fff13 	bx	r3                                             <== NOT EXECUTED
   39af0:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
   39af4:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   39af8:	0a000003 	beq	39b0c <fchdir+0x8c>                           <== NOT EXECUTED
                                          RTEMS_FILESYSTEM_DIRECTORY ) {
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
   39afc:	eb000cff 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   39b00:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   39b04:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   39b08:	ea00001c 	b	39b80 <fchdir+0x100>                            <== NOT EXECUTED
   *         but note the race condition. Threads who                 
   *         share their rtems_filesystem_current better              
   *         be synchronized!                                         
   */                                                                 
                                                                      
  saved                    = rtems_filesystem_current;                
   39b0c:	e59f50c8 	ldr	r5, [pc, #200]	; 39bdc <fchdir+0x15c>         <== NOT EXECUTED
   39b10:	e5957000 	ldr	r7, [r5]                                      <== NOT EXECUTED
   39b14:	e287c004 	add	ip, r7, #4                                    <== NOT EXECUTED
   39b18:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   39b1c:	e28de004 	add	lr, sp, #4                                    <== NOT EXECUTED
   39b20:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   39b24:	e59c3000 	ldr	r3, [ip]                                      <== NOT EXECUTED
   39b28:	e58e3000 	str	r3, [lr]                                      <== NOT EXECUTED
  rtems_filesystem_current = iop->pathinfo;                           
   39b2c:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   39b30:	e287e004 	add	lr, r7, #4                                    <== NOT EXECUTED
   39b34:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   39b38:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
                                                                      
  /* clone the current node */                                        
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
   39b3c:	e3a0e000 	mov	lr, #0                                        <== NOT EXECUTED
   *         share their rtems_filesystem_current better              
   *         be synchronized!                                         
   */                                                                 
                                                                      
  saved                    = rtems_filesystem_current;                
  rtems_filesystem_current = iop->pathinfo;                           
   39b40:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
                                                                      
  /* clone the current node */                                        
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
   39b44:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   39b48:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
   39b4c:	e59f008c 	ldr	r0, [pc, #140]	; 39be0 <fchdir+0x160>         <== NOT EXECUTED
   39b50:	e28d3018 	add	r3, sp, #24                                   <== NOT EXECUTED
   39b54:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
   39b58:	ebff36b7 	bl	763c <rtems_filesystem_evaluate_path>          <== NOT EXECUTED
   39b5c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   39b60:	0a000008 	beq	39b88 <fchdir+0x108>                          <== NOT EXECUTED
    /* cloning failed; restore original and bail out */               
    rtems_filesystem_current = saved;                                 
   39b64:	e595c000 	ldr	ip, [r5]                                      <== NOT EXECUTED
   39b68:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
   39b6c:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   39b70:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
   39b74:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   39b78:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   39b7c:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
   39b80:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
	return -1;                                                           
   39b84:	ea000010 	b	39bcc <fchdir+0x14c>                            <== NOT EXECUTED
  }                                                                   
  /* release the old one */                                           
  rtems_filesystem_freenode( &saved );                                
   39b88:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   39b8c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   39b90:	0a000004 	beq	39ba8 <fchdir+0x128>                          <== NOT EXECUTED
   39b94:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   39b98:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   39b9c:	128d0004 	addne	r0, sp, #4                                  <== NOT EXECUTED
   39ba0:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   39ba4:	112fff13 	bxne	r3                                           <== NOT EXECUTED
                                                                      
  rtems_filesystem_current = loc;                                     
   39ba8:	e59f302c 	ldr	r3, [pc, #44]	; 39bdc <fchdir+0x15c>          <== NOT EXECUTED
   39bac:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
   39bb0:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
   39bb4:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   39bb8:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
   39bbc:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   39bc0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   39bc4:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
   39bc8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   39bcc:	e28dd02c 	add	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
   39bd0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00025084 <fchmod>: mode_t mode ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
   25084:	e59f3068 	ldr	r3, [pc, #104]	; 250f4 <fchmod+0x70>          <== NOT EXECUTED
   25088:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
   2508c:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
                                                                      
int fchmod(                                                           
  int       fd,                                                       
  mode_t    mode                                                      
)                                                                     
{                                                                     
   25090:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
   25094:	2a000005 	bcs	250b0 <fchmod+0x2c>                           <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
   25098:	e59f3058 	ldr	r3, [pc, #88]	; 250f8 <fchmod+0x74>           <== NOT EXECUTED
   2509c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   250a0:	e0833300 	add	r3, r3, r0, lsl #6                            <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
   250a4:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
   250a8:	e3120c01 	tst	r2, #256	; 0x100                              <== NOT EXECUTED
   250ac:	1a000002 	bne	250bc <fchmod+0x38>                           <== NOT EXECUTED
   250b0:	eb005f92 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   250b4:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   250b8:	ea000005 	b	250d4 <fchmod+0x50>                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fchmod().                                       
   */                                                                 
  if ( !iop->handlers->fchmod_h )                                     
   250bc:	e593203c 	ldr	r2, [r3, #60]	; 0x3c                          <== NOT EXECUTED
   250c0:	e592201c 	ldr	r2, [r2, #28]                                 <== NOT EXECUTED
   250c4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   250c8:	1a000004 	bne	250e0 <fchmod+0x5c>                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   250cc:	eb005f8b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   250d0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   250d4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   250d8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   250dc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 
   250e0:	e2830018 	add	r0, r3, #24                                   <== NOT EXECUTED
   250e4:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   250e8:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   250ec:	e593f01c 	ldr	pc, [r3, #28]                                 <== NOT EXECUTED
}                                                                     
   250f0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

000250fc <fchown>: gid_t group ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
   250fc:	e59f3088 	ldr	r3, [pc, #136]	; 2518c <fchown+0x90>          <== NOT EXECUTED
   25100:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
int fchown(                                                           
  int   fd,                                                           
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
   25104:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
   25108:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
   2510c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
int fchown(                                                           
  int   fd,                                                           
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
   25110:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
   25114:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
   25118:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
   2511c:	2a000005 	bcs	25138 <fchown+0x3c>                           <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
   25120:	e59f3068 	ldr	r3, [pc, #104]	; 25190 <fchown+0x94>          <== NOT EXECUTED
   25124:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   25128:	e0830300 	add	r0, r3, r0, lsl #6                            <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
   2512c:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
   25130:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
   25134:	1a000002 	bne	25144 <fchown+0x48>                           <== NOT EXECUTED
   25138:	eb005f70 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   2513c:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   25140:	ea00000a 	b	25170 <fchown+0x74>                             <== NOT EXECUTED
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
   25144:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
   25148:	1a000002 	bne	25158 <fchown+0x5c>                           <== NOT EXECUTED
   2514c:	eb005f6b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25150:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   25154:	ea000005 	b	25170 <fchown+0x74>                             <== NOT EXECUTED
                                                                      
  if ( !iop->pathinfo.ops->chown_h )                                  
   25158:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          <== NOT EXECUTED
   2515c:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
   25160:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25164:	1a000004 	bne	2517c <fchown+0x80>                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   25168:	eb005f64 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   2516c:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   25170:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   25174:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   25178:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
   2517c:	e2800018 	add	r0, r0, #24                                   <== NOT EXECUTED
   25180:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   25184:	e12fff13 	bx	r3                                             <== NOT EXECUTED
}                                                                     
   25188:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00039be4 <fcntl>: int fcntl( int fd, int cmd, ... ) {
   39be4:	e92d000e 	push	{r1, r2, r3}                                 
   39be8:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
   39bec:	e59f31a4 	ldr	r3, [pc, #420]	; 39d98 <fcntl+0x1b4>          
   39bf0:	e5933000 	ldr	r3, [r3]                                      
  ...                                                                 
)                                                                     
{                                                                     
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
   39bf4:	e28d201c 	add	r2, sp, #28                                   
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
   39bf8:	e1500003 	cmp	r0, r3                                        
  ...                                                                 
)                                                                     
{                                                                     
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
   39bfc:	e58d2000 	str	r2, [sp]                                      
int fcntl(                                                            
  int fd,                                                             
  int cmd,                                                            
  ...                                                                 
)                                                                     
{                                                                     
   39c00:	e59d7018 	ldr	r7, [sp, #24]                                 
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
   39c04:	2a000005 	bcs	39c20 <fcntl+0x3c>                            
  iop = rtems_libio_iop( fd );                                        
   39c08:	e59f118c 	ldr	r1, [pc, #396]	; 39d9c <fcntl+0x1b8>          
   39c0c:	e591c000 	ldr	ip, [r1]                                      
   39c10:	e08c4300 	add	r4, ip, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
   39c14:	e5940014 	ldr	r0, [r4, #20]                                 
   39c18:	e3100c01 	tst	r0, #256	; 0x100                              
   39c1c:	1a000002 	bne	39c2c <fcntl+0x48>                            
   39c20:	eb000cb6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   39c24:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   39c28:	ea000045 	b	39d44 <fcntl+0x160>                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
   39c2c:	e3570009 	cmp	r7, #9                                        
   39c30:	979ff107 	ldrls	pc, [pc, r7, lsl #2]                        
   39c34:	ea000040 	b	39d3c <fcntl+0x158>                             
   39c38:	00039c60 	.word	0x00039c60                                  
   39c3c:	00039ccc 	.word	0x00039ccc                                  
   39c40:	00039cd8 	.word	0x00039cd8                                  
   39c44:	00039cf8 	.word	0x00039cf8                                  
   39c48:	00039d04 	.word	0x00039d04                                  
   39c4c:	00039d30 	.word	0x00039d30                                  
   39c50:	00039d30 	.word	0x00039d30                                  
   39c54:	00039d30 	.word	0x00039d30                                  
   39c58:	00039d30 	.word	0x00039d30                                  
   39c5c:	00039d30 	.word	0x00039d30                                  
    case F_DUPFD:        /* dup */                                    
      fd2 = va_arg( ap, int );                                        
   39c60:	e5922000 	ldr	r2, [r2]                                      
      if ( fd2 )                                                      
   39c64:	e3520000 	cmp	r2, #0                                        
   39c68:	0a000003 	beq	39c7c <fcntl+0x98>                            
        diop = rtems_libio_iop( fd2 );                                
   39c6c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   39c70:	23a0c000 	movcs	ip, #0                                      <== NOT EXECUTED
   39c74:	308cc302 	addcc	ip, ip, r2, lsl #6                          <== NOT EXECUTED
   39c78:	ea000002 	b	39c88 <fcntl+0xa4>                              <== NOT EXECUTED
      else {                                                          
        /* allocate a file control block */                           
        diop = rtems_libio_allocate();                                
   39c7c:	ebff3797 	bl	7ae0 <rtems_libio_allocate>                    
        if ( diop == 0 ) {                                            
   39c80:	e250c000 	subs	ip, r0, #0                                   
   39c84:	0a00003e 	beq	39d84 <fcntl+0x1a0>                           
      }                                                               
                                                                      
      diop->handlers   = iop->handlers;                               
      diop->file_info  = iop->file_info;                              
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
   39c88:	e2846018 	add	r6, r4, #24                                   
   39c8c:	e8b6000f 	ldm	r6!, {r0, r1, r2, r3}                         
   39c90:	e28c5018 	add	r5, ip, #24                                   
   39c94:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       
      ret = (int) (diop - rtems_libio_iops);                          
   39c98:	e59f30fc 	ldr	r3, [pc, #252]	; 39d9c <fcntl+0x1b8>          
   39c9c:	e5933000 	ldr	r3, [r3]                                      
      }                                                               
                                                                      
      diop->handlers   = iop->handlers;                               
      diop->file_info  = iop->file_info;                              
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
   39ca0:	e5966000 	ldr	r6, [r6]                                      
          ret = -1;                                                   
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->handlers   = iop->handlers;                               
   39ca4:	e594003c 	ldr	r0, [r4, #60]	; 0x3c                          
      diop->file_info  = iop->file_info;                              
   39ca8:	e5941038 	ldr	r1, [r4, #56]	; 0x38                          
      diop->flags      = iop->flags;                                  
   39cac:	e5942014 	ldr	r2, [r4, #20]                                 
      diop->pathinfo   = iop->pathinfo;                               
      ret = (int) (diop - rtems_libio_iops);                          
   39cb0:	e063300c 	rsb	r3, r3, ip                                    
      }                                                               
                                                                      
      diop->handlers   = iop->handlers;                               
      diop->file_info  = iop->file_info;                              
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
   39cb4:	e5856000 	str	r6, [r5]                                      
          ret = -1;                                                   
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->handlers   = iop->handlers;                               
   39cb8:	e58c003c 	str	r0, [ip, #60]	; 0x3c                          
      diop->file_info  = iop->file_info;                              
   39cbc:	e58c1038 	str	r1, [ip, #56]	; 0x38                          
      diop->flags      = iop->flags;                                  
   39cc0:	e58c2014 	str	r2, [ip, #20]                                 
      diop->pathinfo   = iop->pathinfo;                               
      ret = (int) (diop - rtems_libio_iops);                          
   39cc4:	e1a05343 	asr	r5, r3, #6                                    
   39cc8:	ea00001f 	b	39d4c <fcntl+0x168>                             
      break;                                                          
                                                                      
    case F_GETFD:        /* get f_flags */                            
      ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);          
   39ccc:	e1a055a0 	lsr	r5, r0, #11                                   
   39cd0:	e2055001 	and	r5, r5, #1                                    
   39cd4:	ea00001e 	b	39d54 <fcntl+0x170>                             
       *  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 ) )                                        
   39cd8:	e5925000 	ldr	r5, [r2]                                      
   39cdc:	e3550000 	cmp	r5, #0                                        
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
   39ce0:	13800b02 	orrne	r0, r0, #2048	; 0x800                       
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
   39ce4:	03c00b02 	biceq	r0, r0, #2048	; 0x800                       
       *  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;                      
   39ce8:	15840014 	strne	r0, [r4, #20]                               
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
   39cec:	05840014 	streq	r0, [r4, #20]                               
       *  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 ) )                                        
   39cf0:	0a000017 	beq	39d54 <fcntl+0x170>                           
   39cf4:	ea00000b 	b	39d28 <fcntl+0x144>                             
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
      break;                                                          
                                                                      
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
   39cf8:	ebff370f 	bl	793c <rtems_libio_to_fcntl_flags>              
   39cfc:	e1a05000 	mov	r5, r0                                        
   39d00:	ea000011 	b	39d4c <fcntl+0x168>                             
      break;                                                          
                                                                      
    case F_SETFL:                                                     
      flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );           
   39d04:	e5920000 	ldr	r0, [r2]                                      
   39d08:	ebff37a1 	bl	7b94 <rtems_libio_fcntl_flags>                 
                                                                      
      /*                                                              
       *  XXX If we are turning on append, should we seek to the end? 
       */                                                             
                                                                      
      iop->flags = (iop->flags & ~mask) | (flags & mask);             
   39d0c:	e5943014 	ldr	r3, [r4, #20]                                 
   39d10:	e59f2088 	ldr	r2, [pc, #136]	; 39da0 <fcntl+0x1bc>          
   39d14:	e3c33c02 	bic	r3, r3, #512	; 0x200                          
   39d18:	e0002002 	and	r2, r0, r2                                    
   39d1c:	e3c33001 	bic	r3, r3, #1                                    
   39d20:	e1823003 	orr	r3, r2, r3                                    
   39d24:	e5843014 	str	r3, [r4, #20]                                 
   39d28:	e3a05000 	mov	r5, #0                                        
   39d2c:	ea000008 	b	39d54 <fcntl+0x170>                             
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    case F_GETOWN:       /*  for sockets. */                          
      errno = ENOTSUP;                                                
   39d30:	eb000c72 	bl	3cf00 <__errno>                                
   39d34:	e3a03086 	mov	r3, #134	; 0x86                               
   39d38:	ea000001 	b	39d44 <fcntl+0x160>                             
      ret = -1;                                                       
      break;                                                          
                                                                      
    default:                                                          
      errno = EINVAL;                                                 
   39d3c:	eb000c6f 	bl	3cf00 <__errno>                                
   39d40:	e3a03016 	mov	r3, #22                                       
   39d44:	e5803000 	str	r3, [r0]                                      
   39d48:	ea00000d 	b	39d84 <fcntl+0x1a0>                             
  /*                                                                  
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
   39d4c:	e3550000 	cmp	r5, #0                                        
   39d50:	ba00000c 	blt	39d88 <fcntl+0x1a4>                           
    if (iop->handlers->fcntl_h) {                                     
   39d54:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   39d58:	e5933030 	ldr	r3, [r3, #48]	; 0x30                          
   39d5c:	e3530000 	cmp	r3, #0                                        
   39d60:	0a000008 	beq	39d88 <fcntl+0x1a4>                           
      int err = (*iop->handlers->fcntl_h)( cmd, iop );                
   39d64:	e1a01004 	mov	r1, r4                                        
   39d68:	e1a00007 	mov	r0, r7                                        
   39d6c:	e1a0e00f 	mov	lr, pc                                        
   39d70:	e12fff13 	bx	r3                                             
      if (err) {                                                      
   39d74:	e2504000 	subs	r4, r0, #0                                   
   39d78:	0a000002 	beq	39d88 <fcntl+0x1a4>                           
        errno = err;                                                  
   39d7c:	eb000c5f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   39d80:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
   39d84:	e3e05000 	mvn	r5, #0                                        
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
   39d88:	e1a00005 	mov	r0, r5                                        
   39d8c:	e8bd40f8 	pop	{r3, r4, r5, r6, r7, lr}                      
   39d90:	e28dd00c 	add	sp, sp, #12                                   
   39d94:	e12fff1e 	bx	lr                                             
                                                                      

00002970 <fdatasync>: int fd ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
    2970:	e59f3068 	ldr	r3, [pc, #104]	; 29e0 <fdatasync+0x70>        
    2974:	e5933000 	ldr	r3, [r3]                                      
    2978:	e1500003 	cmp	r0, r3                                        
#include <rtems/seterr.h>                                             
                                                                      
int fdatasync(                                                        
  int     fd                                                          
)                                                                     
{                                                                     
    297c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
    2980:	2a000007 	bcs	29a4 <fdatasync+0x34>                         
  iop = rtems_libio_iop( fd );                                        
    2984:	e59f3058 	ldr	r3, [pc, #88]	; 29e4 <fdatasync+0x74>         
    2988:	e5933000 	ldr	r3, [r3]                                      
    298c:	e0830300 	add	r0, r3, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
    2990:	e5903014 	ldr	r3, [r0, #20]                                 
    2994:	e3130c01 	tst	r3, #256	; 0x100                              
    2998:	0a000001 	beq	29a4 <fdatasync+0x34>                         
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
    299c:	e3130004 	tst	r3, #4                                        
    29a0:	1a000002 	bne	29b0 <fdatasync+0x40>                         
    29a4:	eb002f08 	bl	e5cc <__errno>                                 
    29a8:	e3a03009 	mov	r3, #9                                        
    29ac:	ea000005 	b	29c8 <fdatasync+0x58>                           
                                                                      
  /*                                                                  
   *  Now process the fdatasync().                                    
   */                                                                 
                                                                      
  if ( !iop->handlers->fdatasync_h )                                  
    29b0:	e590303c 	ldr	r3, [r0, #60]	; 0x3c                          
    29b4:	e593302c 	ldr	r3, [r3, #44]	; 0x2c                          
    29b8:	e3530000 	cmp	r3, #0                                        
    29bc:	1a000004 	bne	29d4 <fdatasync+0x64>                         
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    29c0:	eb002f01 	bl	e5cc <__errno>                                 
    29c4:	e3a03086 	mov	r3, #134	; 0x86                               
    29c8:	e5803000 	str	r3, [r0]                                      
    29cc:	e3e00000 	mvn	r0, #0                                        
    29d0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      
  return (*iop->handlers->fdatasync_h)( iop );                        
    29d4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    29d8:	e12fff13 	bx	r3                                             <== NOT EXECUTED
}                                                                     
    29dc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00008cb4 <fifo_open>: ) { pipe_control_t *pipe; int err = 0; if (rtems_semaphore_obtain(rtems_pipe_semaphore,
    8cb4:	e59f331c 	ldr	r3, [pc, #796]	; 8fd8 <fifo_open+0x324>       
 */                                                                   
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
    8cb8:	e92d45f3 	push	{r0, r1, r4, r5, r6, r7, r8, sl, lr}         
    8cbc:	e1a07001 	mov	r7, r1                                        
)                                                                     
{                                                                     
  pipe_control_t *pipe;                                               
  int err = 0;                                                        
                                                                      
  if (rtems_semaphore_obtain(rtems_pipe_semaphore,                    
    8cc0:	e3a01000 	mov	r1, #0                                        
 */                                                                   
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
    8cc4:	e1a06000 	mov	r6, r0                                        
)                                                                     
{                                                                     
  pipe_control_t *pipe;                                               
  int err = 0;                                                        
                                                                      
  if (rtems_semaphore_obtain(rtems_pipe_semaphore,                    
    8cc8:	e1a02001 	mov	r2, r1                                        
    8ccc:	e5930000 	ldr	r0, [r3]                                      
    8cd0:	ebfff131 	bl	519c <rtems_semaphore_obtain>                  
    8cd4:	e250a000 	subs	sl, r0, #0                                   
    8cd8:	13e05003 	mvnne	r5, #3                                      
    8cdc:	1a0000bb 	bne	8fd0 <fifo_open+0x31c>                        
        RTEMS_WAIT, RTEMS_NO_TIMEOUT) != RTEMS_SUCCESSFUL)            
    return -EINTR;                                                    
                                                                      
  pipe = *pipep;                                                      
    8ce0:	e5964000 	ldr	r4, [r6]                                      <== NOT EXECUTED
  if (pipe == NULL) {                                                 
    8ce4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    8ce8:	1a00003b 	bne	8ddc <fifo_open+0x128>                        <== NOT EXECUTED
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
    8cec:	e3a00034 	mov	r0, #52	; 0x34                                <== NOT EXECUTED
    8cf0:	ebffe542 	bl	2200 <malloc>                                  <== NOT EXECUTED
  if (pipe == NULL)                                                   
    8cf4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
    8cf8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    8cfc:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  if (pipe == NULL)                                                   
    8d00:	0a000033 	beq	8dd4 <fifo_open+0x120>                        <== NOT EXECUTED
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
    8d04:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
    8d08:	e3a02034 	mov	r2, #52	; 0x34                                <== NOT EXECUTED
    8d0c:	eb0013f6 	bl	dcec <memset>                                  <== NOT EXECUTED
                                                                      
  pipe->Size = PIPE_BUF;                                              
    8d10:	e3a00c02 	mov	r0, #512	; 0x200                              <== NOT EXECUTED
    8d14:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
  pipe->Buffer = malloc(pipe->Size);                                  
    8d18:	ebffe538 	bl	2200 <malloc>                                  <== NOT EXECUTED
  if (! pipe->Buffer)                                                 
    8d1c:	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);                                  
    8d20:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
  if (! pipe->Buffer)                                                 
    8d24:	0a000028 	beq	8dcc <fifo_open+0x118>                        <== NOT EXECUTED
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
  if (rtems_barrier_create(                                           
    8d28:	e59f52ac 	ldr	r5, [pc, #684]	; 8fdc <fifo_open+0x328>       <== NOT EXECUTED
    8d2c:	e59f02ac 	ldr	r0, [pc, #684]	; 8fe0 <fifo_open+0x32c>       <== NOT EXECUTED
    8d30:	e5d53000 	ldrb	r3, [r5]                                     <== NOT EXECUTED
    8d34:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
    8d38:	e1830000 	orr	r0, r3, r0                                    <== NOT EXECUTED
    8d3c:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
    8d40:	e284302c 	add	r3, r4, #44	; 0x2c                            <== NOT EXECUTED
    8d44:	eb000678 	bl	a72c <rtems_barrier_create>                    <== NOT EXECUTED
    8d48:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
    8d4c:	1a00001c 	bne	8dc4 <fifo_open+0x110>                        <== 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(                                           
    8d50:	e5d53000 	ldrb	r3, [r5]                                     <== NOT EXECUTED
    8d54:	e59f0288 	ldr	r0, [pc, #648]	; 8fe4 <fifo_open+0x330>       <== NOT EXECUTED
    8d58:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    8d5c:	e1830000 	orr	r0, r3, r0                                    <== NOT EXECUTED
    8d60:	e2843030 	add	r3, r4, #48	; 0x30                            <== NOT EXECUTED
    8d64:	eb000670 	bl	a72c <rtems_barrier_create>                    <== NOT EXECUTED
    8d68:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    8d6c:	1a000012 	bne	8dbc <fifo_open+0x108>                        <== 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(                                         
    8d70:	e5d52000 	ldrb	r2, [r5]                                     <== NOT EXECUTED
    8d74:	e59f026c 	ldr	r0, [pc, #620]	; 8fe8 <fifo_open+0x334>       <== NOT EXECUTED
    8d78:	e284c028 	add	ip, r4, #40	; 0x28                            <== NOT EXECUTED
    8d7c:	e1820000 	orr	r0, r2, r0                                    <== NOT EXECUTED
    8d80:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    8d84:	e3a02010 	mov	r2, #16                                       <== NOT EXECUTED
    8d88:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
    8d8c:	ebfff070 	bl	4f54 <rtems_semaphore_create>                  <== NOT EXECUTED
    8d90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8d94:	1a000006 	bne	8db4 <fifo_open+0x100>                        <== NOT EXECUTED
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
    8d98:	e5d53000 	ldrb	r3, [r5]                                     <== NOT EXECUTED
    8d9c:	e353007a 	cmp	r3, #122	; 0x7a                               <== NOT EXECUTED
    8da0:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
    8da4:	e5c53000 	strb	r3, [r5]                                     <== NOT EXECUTED
    c = 'a';                                                          
    8da8:	03a03061 	moveq	r3, #97	; 0x61                              <== NOT EXECUTED
    8dac:	05c53000 	strbeq	r3, [r5]                                   <== NOT EXECUTED
    8db0:	ea000009 	b	8ddc <fifo_open+0x128>                          <== NOT EXECUTED
  return 0;                                                           
                                                                      
err_sem:                                                              
  rtems_barrier_delete(pipe->writeBarrier);                           
    8db4:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
    8db8:	eb000689 	bl	a7e4 <rtems_barrier_delete>                    <== NOT EXECUTED
err_wbar:                                                             
  rtems_barrier_delete(pipe->readBarrier);                            
    8dbc:	e598002c 	ldr	r0, [r8, #44]	; 0x2c                          <== NOT EXECUTED
    8dc0:	eb000687 	bl	a7e4 <rtems_barrier_delete>                    <== NOT EXECUTED
err_rbar:                                                             
  free(pipe->Buffer);                                                 
    8dc4:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
    8dc8:	ebffe440 	bl	1ed0 <free>                                    <== NOT EXECUTED
err_buf:                                                              
  free(pipe);                                                         
    8dcc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    8dd0:	ebffe43e 	bl	1ed0 <free>                                    <== NOT EXECUTED
    8dd4:	e3e0500b 	mvn	r5, #11                                       <== NOT EXECUTED
    8dd8:	ea00000d 	b	8e14 <fifo_open+0x160>                          <== NOT EXECUTED
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    8ddc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    8de0:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8de4:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    8de8:	ebfff0eb 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
    8dec:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    8df0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8df4:	01a05000 	moveq	r5, r0                                      <== NOT EXECUTED
    8df8:	13e05003 	mvnne	r5, #3                                      <== NOT EXECUTED
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
    8dfc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8e00:	1a000003 	bne	8e14 <fifo_open+0x160>                        <== NOT EXECUTED
    if (err)                                                          
    8e04:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
      pipe_free(pipe);                                                
    else                                                              
      *pipep = pipe;                                                  
    8e08:	05864000 	streq	r4, [r6]                                    <== NOT EXECUTED
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
    if (err)                                                          
      pipe_free(pipe);                                                
    8e0c:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    8e10:	1bffff5b 	blne	8b84 <pipe_free>                             <== NOT EXECUTED
    else                                                              
      *pipep = pipe;                                                  
  }                                                                   
                                                                      
out:                                                                  
  rtems_semaphore_release(rtems_pipe_semaphore);                      
    8e14:	e59f31bc 	ldr	r3, [pc, #444]	; 8fd8 <fifo_open+0x324>       <== NOT EXECUTED
    8e18:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    8e1c:	ebfff124 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
  pipe_control_t *pipe;                                               
  unsigned int prevCounter;                                           
  int err;                                                            
                                                                      
  err = pipe_new(pipep);                                              
  if (err)                                                            
    8e20:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    8e24:	1a000069 	bne	8fd0 <fifo_open+0x31c>                        <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    8e28:	e5973014 	ldr	r3, [r7, #20]                                 <== NOT EXECUTED
    8e2c:	e2033006 	and	r3, r3, #6                                    <== NOT EXECUTED
    8e30:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
  int err;                                                            
                                                                      
  err = pipe_new(pipep);                                              
  if (err)                                                            
    return err;                                                       
  pipe = *pipep;                                                      
    8e34:	e5964000 	ldr	r4, [r6]                                      <== NOT EXECUTED
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    8e38:	0a000024 	beq	8ed0 <fifo_open+0x21c>                        <== NOT EXECUTED
    8e3c:	e3530006 	cmp	r3, #6                                        <== NOT EXECUTED
    8e40:	0a000047 	beq	8f64 <fifo_open+0x2b0>                        <== NOT EXECUTED
    8e44:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
    8e48:	1a000059 	bne	8fb4 <fifo_open+0x300>                        <== NOT EXECUTED
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
    8e4c:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
    8e50:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
    8e54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
    8e58:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
    8e5c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
    8e60:	e5842020 	str	r2, [r4, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
    8e64:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
        PIPE_WAKEUPWRITERS(pipe);                                     
    8e68:	05940030 	ldreq	r0, [r4, #48]	; 0x30                        <== NOT EXECUTED
    8e6c:	028d1004 	addeq	r1, sp, #4                                  <== NOT EXECUTED
    8e70:	0b000673 	bleq	a844 <rtems_barrier_release>                 <== NOT EXECUTED
                                                                      
      if (pipe->Writers == 0) {                                       
    8e74:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
    8e78:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8e7c:	1a00004c 	bne	8fb4 <fifo_open+0x300>                        <== NOT EXECUTED
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
    8e80:	e5973014 	ldr	r3, [r7, #20]                                 <== NOT EXECUTED
    8e84:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
    8e88:	1a000049 	bne	8fb4 <fifo_open+0x300>                        <== NOT EXECUTED
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
    8e8c:	e5948024 	ldr	r8, [r4, #36]	; 0x24                          <== NOT EXECUTED
        err = -EINTR;                                                 
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
    8e90:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8e94:	ebfff106 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
          if (! PIPE_READWAIT(pipe))                                  
    8e98:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    8e9c:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
    8ea0:	eb00067d 	bl	a89c <rtems_barrier_wait>                      <== NOT EXECUTED
    8ea4:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
    8ea8:	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))                                  
    8eac:	1a000043 	bne	8fc0 <fifo_open+0x30c>                        <== NOT EXECUTED
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
    8eb0:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8eb4:	ebfff0b8 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    8eb8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8ebc:	1a00003f 	bne	8fc0 <fifo_open+0x30c>                        <== NOT EXECUTED
            goto out_error;                                           
        } while (prevCounter == pipe->writerCounter);                 
    8ec0:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
    8ec4:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
    8ec8:	0afffff0 	beq	8e90 <fifo_open+0x1dc>                        <== NOT EXECUTED
    8ecc:	ea000038 	b	8fb4 <fifo_open+0x300>                          <== NOT EXECUTED
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
    8ed0:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
    8ed4:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
    8ed8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
    8edc:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
    8ee0:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
    8ee4:	e5842024 	str	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
    8ee8:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
        PIPE_WAKEUPREADERS(pipe);                                     
    8eec:	0594002c 	ldreq	r0, [r4, #44]	; 0x2c                        <== NOT EXECUTED
    8ef0:	028d1004 	addeq	r1, sp, #4                                  <== NOT EXECUTED
    8ef4:	0b000652 	bleq	a844 <rtems_barrier_release>                 <== NOT EXECUTED
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
    8ef8:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
    8efc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8f00:	1a00002b 	bne	8fb4 <fifo_open+0x300>                        <== NOT EXECUTED
    8f04:	e5973014 	ldr	r3, [r7, #20]                                 <== NOT EXECUTED
    8f08:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
        err = -ENXIO;                                                 
        goto out_error;                                               
      }                                                               
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
    8f0c:	05948020 	ldreq	r8, [r4, #32]                               <== NOT EXECUTED
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
    8f10:	0a000003 	beq	8f24 <fifo_open+0x270>                        <== NOT EXECUTED
	PIPE_UNLOCK(pipe);                                                   
    8f14:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8f18:	ebfff0e5 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
    8f1c:	e3e05005 	mvn	r5, #5                                        <== NOT EXECUTED
        err = -ENXIO;                                                 
        goto out_error;                                               
    8f20:	ea000027 	b	8fc4 <fifo_open+0x310>                          <== NOT EXECUTED
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
    8f24:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8f28:	ebfff0e1 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
          if (! PIPE_WRITEWAIT(pipe))                                 
    8f2c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    8f30:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
    8f34:	eb000658 	bl	a89c <rtems_barrier_wait>                      <== NOT EXECUTED
    8f38:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
    8f3c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_WRITEWAIT(pipe))                                 
    8f40:	1a00001e 	bne	8fc0 <fifo_open+0x30c>                        <== NOT EXECUTED
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
    8f44:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8f48:	ebfff093 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    8f4c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8f50:	1a00001a 	bne	8fc0 <fifo_open+0x30c>                        <== NOT EXECUTED
            goto out_error;                                           
        } while (prevCounter == pipe->readerCounter);                 
    8f54:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
    8f58:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
    8f5c:	0afffff0 	beq	8f24 <fifo_open+0x270>                        <== NOT EXECUTED
    8f60:	ea000013 	b	8fb4 <fifo_open+0x300>                          <== NOT EXECUTED
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
    8f64:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
    8f68:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
    8f6c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
    8f70:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
    8f74:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
    8f78:	e5842020 	str	r2, [r4, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
    8f7c:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
        PIPE_WAKEUPWRITERS(pipe);                                     
    8f80:	05940030 	ldreq	r0, [r4, #48]	; 0x30                        <== NOT EXECUTED
    8f84:	028d1004 	addeq	r1, sp, #4                                  <== NOT EXECUTED
    8f88:	0b00062d 	bleq	a844 <rtems_barrier_release>                 <== NOT EXECUTED
      pipe->writerCounter ++;                                         
      if (pipe->Writers ++ == 0)                                      
    8f8c:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
    8f90:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
    8f94:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
    8f98:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
    8f9c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
    8fa0:	e5842024 	str	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
    8fa4:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
        PIPE_WAKEUPREADERS(pipe);                                     
    8fa8:	0594002c 	ldreq	r0, [r4, #44]	; 0x2c                        <== NOT EXECUTED
    8fac:	028d1004 	addeq	r1, sp, #4                                  <== NOT EXECUTED
    8fb0:	0b000623 	bleq	a844 <rtems_barrier_release>                 <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
    8fb4:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8fb8:	ebfff0bd 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
  return 0;                                                           
    8fbc:	ea000003 	b	8fd0 <fifo_open+0x31c>                          <== NOT EXECUTED
    8fc0:	e3e05003 	mvn	r5, #3                                        <== NOT EXECUTED
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
    8fc4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    8fc8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    8fcc:	ebfffef9 	bl	8bb8 <pipe_release>                            <== NOT EXECUTED
  return err;                                                         
}                                                                     
    8fd0:	e1a00005 	mov	r0, r5                                        
    8fd4:	e8bd85fc 	pop	{r2, r3, r4, r5, r6, r7, r8, sl, pc}          
                                                                      

000029e8 <fpathconf>: { long return_value; rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd);
    29e8:	e59f30ec 	ldr	r3, [pc, #236]	; 2adc <fpathconf+0xf4>        
    29ec:	e5933000 	ldr	r3, [r3]                                      
    29f0:	e1500003 	cmp	r0, r3                                        
                                                                      
long fpathconf(                                                       
  int   fd,                                                           
  int   name                                                          
)                                                                     
{                                                                     
    29f4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  long                                    return_value;               
  rtems_libio_t                          *iop;                        
  rtems_filesystem_limits_and_options_t  *the_limits;                 
                                                                      
  rtems_libio_check_fd(fd);                                           
    29f8:	2a000005 	bcs	2a14 <fpathconf+0x2c>                         
  iop = rtems_libio_iop(fd);                                          
    29fc:	e59f30dc 	ldr	r3, [pc, #220]	; 2ae0 <fpathconf+0xf8>        
    2a00:	e5933000 	ldr	r3, [r3]                                      
    2a04:	e0830300 	add	r0, r3, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
    2a08:	e5903014 	ldr	r3, [r0, #20]                                 
    2a0c:	e3130c01 	tst	r3, #256	; 0x100                              
    2a10:	1a000004 	bne	2a28 <fpathconf+0x40>                         
    2a14:	eb002eec 	bl	e5cc <__errno>                                 
    2a18:	e3a03009 	mov	r3, #9                                        
    2a1c:	e5803000 	str	r3, [r0]                                      
    2a20:	e3e00000 	mvn	r0, #0                                        
    2a24:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      
  /*                                                                  
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;  
    2a28:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          
                                                                      
  switch ( name ) {                                                   
    2a2c:	e351000b 	cmp	r1, #11                                       
    2a30:	979ff101 	ldrls	pc, [pc, r1, lsl #2]                        
    2a34:	ea000023 	b	2ac8 <fpathconf+0xe0>                           
    2a38:	00002a68 	.word	0x00002a68                                  
    2a3c:	00002a70 	.word	0x00002a70                                  
    2a40:	00002a78 	.word	0x00002a78                                  
    2a44:	00002a80 	.word	0x00002a80                                  
    2a48:	00002a88 	.word	0x00002a88                                  
    2a4c:	00002a90 	.word	0x00002a90                                  
    2a50:	00002a98 	.word	0x00002a98                                  
    2a54:	00002aa0 	.word	0x00002aa0                                  
    2a58:	00002aa8 	.word	0x00002aa8                                  
    2a5c:	00002ab0 	.word	0x00002ab0                                  
    2a60:	00002ab8 	.word	0x00002ab8                                  
    2a64:	00002ac0 	.word	0x00002ac0                                  
    case _PC_LINK_MAX:                                                
      return_value = the_limits->link_max;                            
    2a68:	e5930038 	ldr	r0, [r3, #56]	; 0x38                          
      break;                                                          
    2a6c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_MAX_CANON:                                               
      return_value = the_limits->max_canon;                           
    2a70:	e593003c 	ldr	r0, [r3, #60]	; 0x3c                          
      break;                                                          
    2a74:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_MAX_INPUT:                                               
      return_value = the_limits->max_input;                           
    2a78:	e5930040 	ldr	r0, [r3, #64]	; 0x40                          
      break;                                                          
    2a7c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_NAME_MAX:                                                
      return_value = the_limits->name_max;                            
    2a80:	e5930044 	ldr	r0, [r3, #68]	; 0x44                          
      break;                                                          
    2a84:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_PATH_MAX:                                                
      return_value = the_limits->path_max;                            
    2a88:	e5930048 	ldr	r0, [r3, #72]	; 0x48                          
      break;                                                          
    2a8c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_PIPE_BUF:                                                
      return_value = the_limits->pipe_buf;                            
    2a90:	e593004c 	ldr	r0, [r3, #76]	; 0x4c                          
      break;                                                          
    2a94:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_CHOWN_RESTRICTED:                                        
      return_value = the_limits->posix_chown_restrictions;            
    2a98:	e5930054 	ldr	r0, [r3, #84]	; 0x54                          
      break;                                                          
    2a9c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_NO_TRUNC:                                                
      return_value = the_limits->posix_no_trunc;                      
    2aa0:	e5930058 	ldr	r0, [r3, #88]	; 0x58                          
      break;                                                          
    2aa4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_VDISABLE:                                                
      return_value = the_limits->posix_vdisable;                      
    2aa8:	e5930064 	ldr	r0, [r3, #100]	; 0x64                         
      break;                                                          
    2aac:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_ASYNC_IO:                                                
      return_value = the_limits->posix_async_io;                      
    2ab0:	e5930050 	ldr	r0, [r3, #80]	; 0x50                          
      break;                                                          
    2ab4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
    2ab8:	e593005c 	ldr	r0, [r3, #92]	; 0x5c                          
      break;                                                          
    2abc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    case _PC_SYNC_IO:                                                 
      return_value = the_limits->posix_sync_io;                       
    2ac0:	e5930060 	ldr	r0, [r3, #96]	; 0x60                          
      break;                                                          
    2ac4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    2ac8:	eb002ebf 	bl	e5cc <__errno>                                 
    2acc:	e3a03016 	mov	r3, #22                                       
    2ad0:	e5803000 	str	r3, [r0]                                      
    2ad4:	e3e00000 	mvn	r0, #0                                        
      break;                                                          
  }                                                                   
                                                                      
  return return_value;                                                
}                                                                     
    2ad8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

00001ed0 <free>: void free( void *ptr ) { MSBUMP(free_calls, 1);
    1ed0:	e59f3088 	ldr	r3, [pc, #136]	; 1f60 <free+0x90>             
    1ed4:	e593200c 	ldr	r2, [r3, #12]                                 
    1ed8:	e92d4030 	push	{r4, r5, lr}                                 
    1edc:	e2822001 	add	r2, r2, #1                                    
                                                                      
  if ( !ptr )                                                         
    1ee0:	e2504000 	subs	r4, r0, #0                                   
                                                                      
void free(                                                            
  void *ptr                                                           
)                                                                     
{                                                                     
  MSBUMP(free_calls, 1);                                              
    1ee4:	e583200c 	str	r2, [r3, #12]                                 
                                                                      
  if ( !ptr )                                                         
    1ee8:	08bd8030 	popeq	{r4, r5, pc}                                
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
                                                                      
  if ( _System_state_Is_up(_System_state_Get()) &&                    
    1eec:	e59f3070 	ldr	r3, [pc, #112]	; 1f64 <free+0x94>             
    1ef0:	e5933000 	ldr	r3, [r3]                                      
    1ef4:	e3530003 	cmp	r3, #3                                        
    1ef8:	1a000005 	bne	1f14 <free+0x44>                              
    1efc:	eb000065 	bl	2098 <malloc_is_system_state_OK>               
    1f00:	e3500000 	cmp	r0, #0                                        
    1f04:	1a000002 	bne	1f14 <free+0x44>                              
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
    1f08:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
      RTEMS_Malloc_Heap->area_begin,                                  
      RTEMS_Malloc_Heap->area_end                                     
    );                                                                
  }                                                                   
                                                                      
}                                                                     
    1f0c:	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);                                      
    1f10:	ea000073 	b	20e4 <malloc_deferred_free>                     <== NOT EXECUTED
  #endif                                                              
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
    1f14:	e59f304c 	ldr	r3, [pc, #76]	; 1f68 <free+0x98>              
    1f18:	e5933000 	ldr	r3, [r3]                                      
    1f1c:	e3530000 	cmp	r3, #0                                        
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
    1f20:	11a00004 	movne	r0, r4                                      
    1f24:	11a0e00f 	movne	lr, pc                                      
    1f28:	1593f008 	ldrne	pc, [r3, #8]                                
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
    1f2c:	e59f5038 	ldr	r5, [pc, #56]	; 1f6c <free+0x9c>              
    1f30:	e1a01004 	mov	r1, r4                                        
    1f34:	e5950000 	ldr	r0, [r5]                                      
    1f38:	eb0012d9 	bl	6aa4 <_Protected_heap_Free>                    
    1f3c:	e3500000 	cmp	r0, #0                                        
    1f40:	18bd8030 	popne	{r4, r5, pc}                                
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
      ptr,                                                            
      RTEMS_Malloc_Heap->area_begin,                                  
    1f44:	e5952000 	ldr	r2, [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",
    1f48:	e59f0020 	ldr	r0, [pc, #32]	; 1f70 <free+0xa0>              <== NOT EXECUTED
    1f4c:	e2822018 	add	r2, r2, #24                                   <== NOT EXECUTED
    1f50:	e892000c 	ldm	r2, {r2, r3}                                  <== NOT EXECUTED
    1f54:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
      RTEMS_Malloc_Heap->area_begin,                                  
      RTEMS_Malloc_Heap->area_end                                     
    );                                                                
  }                                                                   
                                                                      
}                                                                     
    1f58:	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",
    1f5c:	ea00036f 	b	2d20 <printk>                                   <== NOT EXECUTED
                                                                      

000264e8 <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
   264e8:	e59f3058 	ldr	r3, [pc, #88]	; 26548 <free_user_env+0x60>    <== NOT EXECUTED
   264ec:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
 * NOTE: this must be called with                                     
 *       thread dispatching disabled!                                 
 */                                                                   
static void                                                           
free_user_env(void *venv)                                             
{                                                                     
   264f0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   264f4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_user_env_t *env = (rtems_user_env_t*) venv ;                  
                                                                      
	if (env != &rtems_global_user_env                                    
   264f8:	08bd8010 	popeq	{r4, pc}                                    <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT                                            
		&& --env->refcnt <= 0                                               
#endif                                                                
		) {                                                                 
		rtems_filesystem_freenode( &env->current_directory);                
   264fc:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   26500:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26504:	0a000004 	beq	2651c <free_user_env+0x34>                    <== NOT EXECUTED
   26508:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   2650c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26510:	12800004 	addne	r0, r0, #4                                  <== NOT EXECUTED
   26514:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   26518:	112fff13 	bxne	r3                                           <== NOT EXECUTED
		rtems_filesystem_freenode( &env->root_directory);                   
   2651c:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
   26520:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26524:	0a000004 	beq	2653c <free_user_env+0x54>                    <== NOT EXECUTED
   26528:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   2652c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26530:	12840018 	addne	r0, r4, #24                                 <== NOT EXECUTED
   26534:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   26538:	112fff13 	bxne	r3                                           <== NOT EXECUTED
		free(env);                                                          
   2653c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
	}                                                                    
}                                                                     
   26540:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
		&& --env->refcnt <= 0                                               
#endif                                                                
		) {                                                                 
		rtems_filesystem_freenode( &env->current_directory);                
		rtems_filesystem_freenode( &env->root_directory);                   
		free(env);                                                          
   26544:	eaff845a 	b	76b4 <free>                                     <== NOT EXECUTED
                                                                      

00018cdc <fstat>: int fstat( int fd, struct stat *sbuf ) {
   18cdc:	e92d4030 	push	{r4, r5, lr}                                 
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !sbuf )                                                        
   18ce0:	e2515000 	subs	r5, r1, #0                                   
   18ce4:	1a000002 	bne	18cf4 <fstat+0x18>                            
    rtems_set_errno_and_return_minus_one( EFAULT );                   
   18ce8:	ebffd1b5 	bl	d3c4 <__errno>                                 
   18cec:	e3a0300e 	mov	r3, #14                                       
   18cf0:	ea000014 	b	18d48 <fstat+0x6c>                              
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
                                                                      
  iop = rtems_libio_iop( fd );                                        
   18cf4:	e59f3080 	ldr	r3, [pc, #128]	; 18d7c <fstat+0xa0>           
   18cf8:	e5933000 	ldr	r3, [r3]                                      
   18cfc:	e1500003 	cmp	r0, r3                                        
   18d00:	2a000008 	bcs	18d28 <fstat+0x4c>                            
   18d04:	e59f3074 	ldr	r3, [pc, #116]	; 18d80 <fstat+0xa4>           
   18d08:	e5934000 	ldr	r4, [r3]                                      
   18d0c:	e0844300 	add	r4, r4, r0, lsl #6                            
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
   18d10:	e5943014 	ldr	r3, [r4, #20]                                 
   18d14:	e3130c01 	tst	r3, #256	; 0x100                              
   18d18:	0a000002 	beq	18d28 <fstat+0x4c>                            
                                                                      
  if ( !iop->handlers )                                               
   18d1c:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   18d20:	e3530000 	cmp	r3, #0                                        
   18d24:	1a000002 	bne	18d34 <fstat+0x58>                            
    rtems_set_errno_and_return_minus_one( EBADF );                    
   18d28:	ebffd1a5 	bl	d3c4 <__errno>                                 
   18d2c:	e3a03009 	mov	r3, #9                                        
   18d30:	ea000004 	b	18d48 <fstat+0x6c>                              
                                                                      
  if ( !iop->handlers->fstat_h )                                      
   18d34:	e5933018 	ldr	r3, [r3, #24]                                 
   18d38:	e3530000 	cmp	r3, #0                                        
   18d3c:	1a000004 	bne	18d54 <fstat+0x78>                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   18d40:	ebffd19f 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   18d44:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   18d48:	e5803000 	str	r3, [r0]                                      
   18d4c:	e3e00000 	mvn	r0, #0                                        
   18d50:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
  memset( sbuf, 0, sizeof(struct stat) );                             
   18d54:	e3a01000 	mov	r1, #0                                        
   18d58:	e3a02048 	mov	r2, #72	; 0x48                                
   18d5c:	e1a00005 	mov	r0, r5                                        
   18d60:	ebffd3e1 	bl	dcec <memset>                                  
                                                                      
  return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );           
   18d64:	e2840018 	add	r0, r4, #24                                   
   18d68:	e1a01005 	mov	r1, r5                                        
   18d6c:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   18d70:	e1a0e00f 	mov	lr, pc                                        
   18d74:	e593f018 	ldr	pc, [r3, #24]                                 
}                                                                     
   18d78:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

00025248 <fsync>: int fd ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
   25248:	e59f3068 	ldr	r3, [pc, #104]	; 252b8 <fsync+0x70>           
   2524c:	e5933000 	ldr	r3, [r3]                                      
   25250:	e1500003 	cmp	r0, r3                                        
#include <rtems/seterr.h>                                             
                                                                      
int fsync(                                                            
  int     fd                                                          
)                                                                     
{                                                                     
   25254:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
   25258:	2a000008 	bcs	25280 <fsync+0x38>                            
  iop = rtems_libio_iop( fd );                                        
   2525c:	e59f3058 	ldr	r3, [pc, #88]	; 252bc <fsync+0x74>            
   25260:	e5933000 	ldr	r3, [r3]                                      
   25264:	e0830300 	add	r0, r3, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
   25268:	e5903014 	ldr	r3, [r0, #20]                                 
   2526c:	e3130c01 	tst	r3, #256	; 0x100                              
   25270:	0a000002 	beq	25280 <fsync+0x38>                            
                                                                      
  /*                                                                  
   *  Now process the fsync().                                        
   */                                                                 
                                                                      
  if ( !iop->handlers )                                               
   25274:	e590303c 	ldr	r3, [r0, #60]	; 0x3c                          
   25278:	e3530000 	cmp	r3, #0                                        
   2527c:	1a000002 	bne	2528c <fsync+0x44>                            
    rtems_set_errno_and_return_minus_one( EBADF );                    
   25280:	eb005f1e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25284:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   25288:	ea000004 	b	252a0 <fsync+0x58>                              <== NOT EXECUTED
                                                                      
  if ( !iop->handlers->fsync_h )                                      
   2528c:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          
   25290:	e3530000 	cmp	r3, #0                                        
   25294:	1a000004 	bne	252ac <fsync+0x64>                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   25298:	eb005f18 	bl	3cf00 <__errno>                                
   2529c:	e3a03086 	mov	r3, #134	; 0x86                               
   252a0:	e5803000 	str	r3, [r0]                                      
   252a4:	e3e00000 	mvn	r0, #0                                        
   252a8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      
  return (*iop->handlers->fsync_h)( iop );                            
   252ac:	e1a0e00f 	mov	lr, pc                                        
   252b0:	e12fff13 	bx	r3                                             
}                                                                     
   252b4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

0000a0f4 <ftruncate>: int ftruncate( int fd, off_t length ) {
    a0f4:	e92d4070 	push	{r4, r5, r6, lr}                             
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
    a0f8:	e59f30dc 	ldr	r3, [pc, #220]	; a1dc <ftruncate+0xe8>        
    a0fc:	e5933000 	ldr	r3, [r3]                                      
    a100:	e1500003 	cmp	r0, r3                                        
                                                                      
int ftruncate(                                                        
  int     fd,                                                         
  off_t   length                                                      
)                                                                     
{                                                                     
    a104:	e24dd014 	sub	sp, sp, #20                                   
    a108:	e1a05001 	mov	r5, r1                                        
    a10c:	e1a06002 	mov	r6, r2                                        
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
    a110:	2a000005 	bcs	a12c <ftruncate+0x38>                         
  iop = rtems_libio_iop( fd );                                        
    a114:	e59f30c4 	ldr	r3, [pc, #196]	; a1e0 <ftruncate+0xec>        
    a118:	e5934000 	ldr	r4, [r3]                                      
    a11c:	e0844300 	add	r4, r4, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
    a120:	e5943014 	ldr	r3, [r4, #20]                                 
    a124:	e3130c01 	tst	r3, #256	; 0x100                              
    a128:	1a000002 	bne	a138 <ftruncate+0x44>                         
    a12c:	eb000ca4 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a130:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
    a134:	ea00001e 	b	a1b4 <ftruncate+0xc0>                           <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
    a138:	e3130004 	tst	r3, #4                                        
    a13c:	0a000013 	beq	a190 <ftruncate+0x9c>                         
                                                                      
  /*                                                                  
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
    a140:	e284e018 	add	lr, r4, #24                                   
    a144:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    a148:	e1a0c00d 	mov	ip, sp                                        
    a14c:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
  if ( !loc.ops->node_type_h )                                        
    a150:	e5933010 	ldr	r3, [r3, #16]                                 
                                                                      
  /*                                                                  
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
    a154:	e59e2000 	ldr	r2, [lr]                                      
  if ( !loc.ops->node_type_h )                                        
    a158:	e3530000 	cmp	r3, #0                                        
                                                                      
  /*                                                                  
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
    a15c:	e58c2000 	str	r2, [ip]                                      
  if ( !loc.ops->node_type_h )                                        
    a160:	0a000011 	beq	a1ac <ftruncate+0xb8>                         
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
    a164:	e1a0000d 	mov	r0, sp                                        
    a168:	e1a0e00f 	mov	lr, pc                                        
    a16c:	e12fff13 	bx	r3                                             
    a170:	e3500001 	cmp	r0, #1                                        
    a174:	1a000002 	bne	a184 <ftruncate+0x90>                         
    rtems_set_errno_and_return_minus_one( EISDIR );                   
    a178:	eb000c91 	bl	d3c4 <__errno>                                 
    a17c:	e3a03015 	mov	r3, #21                                       
    a180:	ea00000b 	b	a1b4 <ftruncate+0xc0>                           
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
    a184:	e5943014 	ldr	r3, [r4, #20]                                 
    a188:	e3130004 	tst	r3, #4                                        
    a18c:	1a000002 	bne	a19c <ftruncate+0xa8>                         
    a190:	eb000c8b 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a194:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    a198:	ea000005 	b	a1b4 <ftruncate+0xc0>                           <== NOT EXECUTED
                                                                      
  if ( !iop->handlers->ftruncate_h )                                  
    a19c:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
    a1a0:	e5933020 	ldr	r3, [r3, #32]                                 
    a1a4:	e3530000 	cmp	r3, #0                                        
    a1a8:	1a000004 	bne	a1c0 <ftruncate+0xcc>                         
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    a1ac:	eb000c84 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a1b0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    a1b4:	e5803000 	str	r3, [r0]                                      
    a1b8:	e3e00000 	mvn	r0, #0                                        
    a1bc:	ea000004 	b	a1d4 <ftruncate+0xe0>                           
                                                                      
  return (*iop->handlers->ftruncate_h)( iop, length );                
    a1c0:	e1a00004 	mov	r0, r4                                        
    a1c4:	e1a01005 	mov	r1, r5                                        
    a1c8:	e1a02006 	mov	r2, r6                                        
    a1cc:	e1a0e00f 	mov	lr, pc                                        
    a1d0:	e12fff13 	bx	r3                                             
}                                                                     
    a1d4:	e28dd014 	add	sp, sp, #20                                   
    a1d8:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00056a9c <getdents>: /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd );
   56a9c:	e59f30a8 	ldr	r3, [pc, #168]	; 56b4c <getdents+0xb0>        
   56aa0:	e5933000 	ldr	r3, [r3]                                      
   56aa4:	e1500003 	cmp	r0, r3                                        
   56aa8:	359f30a0 	ldrcc	r3, [pc, #160]	; 56b50 <getdents+0xb4>      
int getdents(                                                         
  int   dd_fd,                                                        
  char *dd_buf,                                                       
  int   dd_len                                                        
)                                                                     
{                                                                     
   56aac:	e92d4070 	push	{r4, r5, r6, lr}                             
                                                                      
  /*                                                                  
   *  Get the file control block structure associated with the file descriptor
   */                                                                 
                                                                      
  iop = rtems_libio_iop( dd_fd );                                     
   56ab0:	35934000 	ldrcc	r4, [r3]                                    
   56ab4:	23a04000 	movcs	r4, #0                                      
   56ab8:	30844300 	addcc	r4, r4, r0, lsl #6                          
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
   56abc:	e284e018 	add	lr, r4, #24                                   
int getdents(                                                         
  int   dd_fd,                                                        
  char *dd_buf,                                                       
  int   dd_len                                                        
)                                                                     
{                                                                     
   56ac0:	e24dd014 	sub	sp, sp, #20                                   
   56ac4:	e1a06001 	mov	r6, r1                                        
   56ac8:	e1a05002 	mov	r5, r2                                        
  iop = rtems_libio_iop( dd_fd );                                     
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
   56acc:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
   56ad0:	e1a0c00d 	mov	ip, sp                                        
   56ad4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
  if ( !loc.ops->node_type_h )                                        
   56ad8:	e5933010 	ldr	r3, [r3, #16]                                 
  iop = rtems_libio_iop( dd_fd );                                     
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
   56adc:	e59e2000 	ldr	r2, [lr]                                      
  if ( !loc.ops->node_type_h )                                        
   56ae0:	e3530000 	cmp	r3, #0                                        
  iop = rtems_libio_iop( dd_fd );                                     
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
   56ae4:	e58c2000 	str	r2, [ip]                                      
  if ( !loc.ops->node_type_h )                                        
   56ae8:	0a00000d 	beq	56b24 <getdents+0x88>                         
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
   56aec:	e1a0000d 	mov	r0, sp                                        
   56af0:	e1a0e00f 	mov	lr, pc                                        
   56af4:	e12fff13 	bx	r3                                             
   56af8:	e3500001 	cmp	r0, #1                                        
   56afc:	0a000004 	beq	56b14 <getdents+0x78>                         
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
   56b00:	ebff98fe 	bl	3cf00 <__errno>                                
   56b04:	e3a03014 	mov	r3, #20                                       
   56b08:	e5803000 	str	r3, [r0]                                      
   56b0c:	e3e00000 	mvn	r0, #0                                        
   56b10:	ea00000b 	b	56b44 <getdents+0xa8>                           
  /*                                                                  
   *  Return the number of bytes that were actually transfered as a result
   *  of the read attempt.                                            
   */                                                                 
                                                                      
  if ( !iop->handlers->read_h )                                       
   56b14:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   56b18:	e5933008 	ldr	r3, [r3, #8]                                  
   56b1c:	e3530000 	cmp	r3, #0                                        
   56b20:	1a000002 	bne	56b30 <getdents+0x94>                         
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   56b24:	ebff98f5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   56b28:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   56b2c:	eafffff5 	b	56b08 <getdents+0x6c>                           <== NOT EXECUTED
                                                                      
  return (*iop->handlers->read_h)( iop, dd_buf, dd_len  );            
   56b30:	e1a00004 	mov	r0, r4                                        
   56b34:	e1a01006 	mov	r1, r6                                        
   56b38:	e1a02005 	mov	r2, r5                                        
   56b3c:	e1a0e00f 	mov	lr, pc                                        
   56b40:	e12fff13 	bx	r3                                             
}                                                                     
   56b44:	e28dd014 	add	sp, sp, #20                                   
   56b48:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

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

000259e0 <getgr_r>: struct group *grp, char *buffer, size_t bufsize, struct group **result ) {
   259e0:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
   259e4:	e59da01c 	ldr	sl, [sp, #28]                                 
   259e8:	e1a06000 	mov	r6, r0                                        
   259ec:	e1a07001 	mov	r7, r1                                        
   259f0:	e1a04002 	mov	r4, r2                                        
   259f4:	e1a08003 	mov	r8, r3                                        
  FILE *fp;                                                           
  int match;                                                          
                                                                      
  init_etc_passwd_group();                                            
   259f8:	ebffffb7 	bl	258dc <init_etc_passwd_group>                  
                                                                      
  if ((fp = fopen("/etc/group", "r")) == NULL) {                      
   259fc:	e59f00a4 	ldr	r0, [pc, #164]	; 25aa8 <getgr_r+0xc8>         
   25a00:	e59f10a4 	ldr	r1, [pc, #164]	; 25aac <getgr_r+0xcc>         
   25a04:	eb005fad 	bl	3d8c0 <fopen>                                  
   25a08:	e2505000 	subs	r5, r0, #0                                   
   25a0c:	1a000003 	bne	25a20 <getgr_r+0x40>                          
    errno = EINVAL;                                                   
   25a10:	eb005d3a 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25a14:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   25a18:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   25a1c:	ea00000c 	b	25a54 <getgr_r+0x74>                            <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
  for(;;) {                                                           
    if (!scangr(fp, grp, buffer, bufsize)) {                          
   25a20:	e1a01004 	mov	r1, r4                                        
   25a24:	e1a02008 	mov	r2, r8                                        
   25a28:	e1a0300a 	mov	r3, sl                                        
   25a2c:	e1a00005 	mov	r0, r5                                        
   25a30:	ebfffef2 	bl	25600 <scangr>                                 
   25a34:	e3500000 	cmp	r0, #0                                        
      errno = EINVAL;                                                 
      fclose(fp);                                                     
      return -1;                                                      
    }                                                                 
    if (name) {                                                       
      match = (strcmp(grp->gr_name, name) == 0);                      
   25a38:	e1a01006 	mov	r1, r6                                        
  if ((fp = fopen("/etc/group", "r")) == NULL) {                      
    errno = EINVAL;                                                   
    return -1;                                                        
  }                                                                   
  for(;;) {                                                           
    if (!scangr(fp, grp, buffer, bufsize)) {                          
   25a3c:	1a000006 	bne	25a5c <getgr_r+0x7c>                          
      errno = EINVAL;                                                 
   25a40:	eb005d2e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25a44:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   25a48:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
      fclose(fp);                                                     
   25a4c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   25a50:	eb005d77 	bl	3d034 <fclose>                                 <== NOT EXECUTED
   25a54:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
      return -1;                                                      
   25a58:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    }                                                                 
    if (name) {                                                       
   25a5c:	e3560000 	cmp	r6, #0                                        
   25a60:	0a000004 	beq	25a78 <getgr_r+0x98>                          
      match = (strcmp(grp->gr_name, name) == 0);                      
   25a64:	e5940000 	ldr	r0, [r4]                                      
   25a68:	eb0075b9 	bl	43154 <strcmp>                                 
   25a6c:	e2700001 	rsbs	r0, r0, #1                                   
   25a70:	33a00000 	movcc	r0, #0                                      
   25a74:	ea000003 	b	25a88 <getgr_r+0xa8>                            
    }                                                                 
    else {                                                            
      match = (grp->gr_gid == gid);                                   
   25a78:	e1d400b8 	ldrh	r0, [r4, #8]                                 <== NOT EXECUTED
   25a7c:	e1500007 	cmp	r0, r7                                        <== NOT EXECUTED
   25a80:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
   25a84:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
    }                                                                 
    if (match) {                                                      
   25a88:	e3500000 	cmp	r0, #0                                        
   25a8c:	0affffe3 	beq	25a20 <getgr_r+0x40>                          
      fclose(fp);                                                     
   25a90:	e1a00005 	mov	r0, r5                                        
   25a94:	eb005d66 	bl	3d034 <fclose>                                 
      *result = grp;                                                  
   25a98:	e59d3020 	ldr	r3, [sp, #32]                                 
   25a9c:	e3a00000 	mov	r0, #0                                        
   25aa0:	e5834000 	str	r4, [r3]                                      
    }                                                                 
  }                                                                   
  fclose(fp);                                                         
  errno = EINVAL;                                                     
  return -1;                                                          
}                                                                     
   25aa4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

00025738 <getgrent>: return NULL; return p; } struct group *getgrent(void) {
   25738:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if (group_fp == NULL)                                               
   2573c:	e59f402c 	ldr	r4, [pc, #44]	; 25770 <getgrent+0x38>         <== NOT EXECUTED
   25740:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   25744:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   25748:	0a000006 	beq	25768 <getgrent+0x30>                         <== NOT EXECUTED
    return NULL;                                                      
  if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))                 
   2574c:	e2841008 	add	r1, r4, #8                                    <== NOT EXECUTED
   25750:	e2842018 	add	r2, r4, #24                                   <== NOT EXECUTED
   25754:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
   25758:	ebffffa8 	bl	25600 <scangr>                                 <== NOT EXECUTED
   2575c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   25760:	12840008 	addne	r0, r4, #8                                  <== NOT EXECUTED
   25764:	18bd8010 	popne	{r4, pc}                                    <== NOT EXECUTED
   25768:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
  return &grent;                                                      
}                                                                     
   2576c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00025ae4 <getgrgid>: struct group *getgrgid( gid_t gid ) {
   25ae4:	e92d4003 	push	{r0, r1, lr}                                 <== NOT EXECUTED
  struct group *p;                                                    
                                                                      
  if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))                
   25ae8:	e59f1028 	ldr	r1, [pc, #40]	; 25b18 <getgrgid+0x34>         <== NOT EXECUTED
}                                                                     
                                                                      
struct group *getgrgid(                                               
  gid_t gid                                                           
)                                                                     
{                                                                     
   25aec:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
  struct group *p;                                                    
                                                                      
  if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))                
   25af0:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
   25af4:	e2812010 	add	r2, r1, #16                                   <== NOT EXECUTED
   25af8:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
   25afc:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
   25b00:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   25b04:	ebffffe9 	bl	25ab0 <getgrgid_r>                             <== NOT EXECUTED
   25b08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   25b0c:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
    return NULL;                                                      
  return p;                                                           
   25b10:	059d0004 	ldreq	r0, [sp, #4]                                <== NOT EXECUTED
}                                                                     
   25b14:	e8bd800c 	pop	{r2, r3, pc}                                  <== NOT EXECUTED
                                                                      

00025ab0 <getgrgid_r>: struct group *grp, char *buffer, size_t bufsize, struct group **result ) {
   25ab0:	e92d4003 	push	{r0, r1, lr}                                 <== NOT EXECUTED
   25ab4:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
   25ab8:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
  return getgr_r(NULL, gid, grp, buffer, bufsize, result);            
   25abc:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  struct group   *grp,                                                
  char           *buffer,                                             
  size_t          bufsize,                                            
  struct group  **result                                              
)                                                                     
{                                                                     
   25ac0:	e1a01800 	lsl	r1, r0, #16                                   <== NOT EXECUTED
  return getgr_r(NULL, gid, grp, buffer, bufsize, result);            
   25ac4:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
   25ac8:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
   25acc:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
   25ad0:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
   25ad4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   25ad8:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   25adc:	ebffffbf 	bl	259e0 <getgr_r>                                <== NOT EXECUTED
}                                                                     
   25ae0:	e8bd800c 	pop	{r2, r3, pc}                                  <== NOT EXECUTED
                                                                      

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

00025bb0 <getpw_r>: struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) {
   25bb0:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
   25bb4:	e59da01c 	ldr	sl, [sp, #28]                                 
   25bb8:	e1a06000 	mov	r6, r0                                        
   25bbc:	e1a07001 	mov	r7, r1                                        
   25bc0:	e1a04002 	mov	r4, r2                                        
   25bc4:	e1a08003 	mov	r8, r3                                        
  FILE *fp;                                                           
  int match;                                                          
                                                                      
  init_etc_passwd_group();                                            
   25bc8:	ebffff43 	bl	258dc <init_etc_passwd_group>                  
                                                                      
  if ((fp = fopen("/etc/passwd", "r")) == NULL) {                     
   25bcc:	e59f00a4 	ldr	r0, [pc, #164]	; 25c78 <getpw_r+0xc8>         
   25bd0:	e59f10a4 	ldr	r1, [pc, #164]	; 25c7c <getpw_r+0xcc>         
   25bd4:	eb005f39 	bl	3d8c0 <fopen>                                  
   25bd8:	e2505000 	subs	r5, r0, #0                                   
   25bdc:	1a000003 	bne	25bf0 <getpw_r+0x40>                          
    errno = EINVAL;                                                   
   25be0:	eb005cc6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25be4:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   25be8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   25bec:	ea00000c 	b	25c24 <getpw_r+0x74>                            <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
  for(;;) {                                                           
    if (!scanpw(fp, pwd, buffer, bufsize)) {                          
   25bf0:	e1a01004 	mov	r1, r4                                        
   25bf4:	e1a02008 	mov	r2, r8                                        
   25bf8:	e1a0300a 	mov	r3, sl                                        
   25bfc:	e1a00005 	mov	r0, r5                                        
   25c00:	ebfffedb 	bl	25774 <scanpw>                                 
   25c04:	e3500000 	cmp	r0, #0                                        
      errno = EINVAL;                                                 
      fclose(fp);                                                     
      return -1;                                                      
    }                                                                 
    if (name) {                                                       
      match = (strcmp(pwd->pw_name, name) == 0);                      
   25c08:	e1a01006 	mov	r1, r6                                        
  if ((fp = fopen("/etc/passwd", "r")) == NULL) {                     
    errno = EINVAL;                                                   
    return -1;                                                        
  }                                                                   
  for(;;) {                                                           
    if (!scanpw(fp, pwd, buffer, bufsize)) {                          
   25c0c:	1a000006 	bne	25c2c <getpw_r+0x7c>                          
      errno = EINVAL;                                                 
   25c10:	eb005cba 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25c14:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   25c18:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
      fclose(fp);                                                     
   25c1c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   25c20:	eb005d03 	bl	3d034 <fclose>                                 <== NOT EXECUTED
   25c24:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
      return -1;                                                      
   25c28:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    }                                                                 
    if (name) {                                                       
   25c2c:	e3560000 	cmp	r6, #0                                        
   25c30:	0a000004 	beq	25c48 <getpw_r+0x98>                          
      match = (strcmp(pwd->pw_name, name) == 0);                      
   25c34:	e5940000 	ldr	r0, [r4]                                      
   25c38:	eb007545 	bl	43154 <strcmp>                                 
   25c3c:	e2700001 	rsbs	r0, r0, #1                                   
   25c40:	33a00000 	movcc	r0, #0                                      
   25c44:	ea000003 	b	25c58 <getpw_r+0xa8>                            
    }                                                                 
    else {                                                            
      match = (pwd->pw_uid == uid);                                   
   25c48:	e1d400b8 	ldrh	r0, [r4, #8]                                 <== NOT EXECUTED
   25c4c:	e1500007 	cmp	r0, r7                                        <== NOT EXECUTED
   25c50:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
   25c54:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
    }                                                                 
    if (match) {                                                      
   25c58:	e3500000 	cmp	r0, #0                                        
   25c5c:	0affffe3 	beq	25bf0 <getpw_r+0x40>                          
      fclose(fp);                                                     
   25c60:	e1a00005 	mov	r0, r5                                        
   25c64:	eb005cf2 	bl	3d034 <fclose>                                 
      *result = pwd;                                                  
   25c68:	e59d3020 	ldr	r3, [sp, #32]                                 
   25c6c:	e3a00000 	mov	r0, #0                                        
   25c70:	e5834000 	str	r4, [r3]                                      
    }                                                                 
  }                                                                   
  fclose(fp);                                                         
  errno = EINVAL;                                                     
  return -1;                                                          
}                                                                     
   25c74:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

000258a0 <getpwent>: return NULL; return p; } struct passwd *getpwent(void) {
   258a0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if (passwd_fp == NULL)                                              
   258a4:	e59f402c 	ldr	r4, [pc, #44]	; 258d8 <getpwent+0x38>         <== NOT EXECUTED
   258a8:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
   258ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   258b0:	0a000006 	beq	258d0 <getpwent+0x30>                         <== NOT EXECUTED
    return NULL;                                                      
  if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))                
   258b4:	e28410e0 	add	r1, r4, #224	; 0xe0                           <== NOT EXECUTED
   258b8:	e28420fc 	add	r2, r4, #252	; 0xfc                           <== NOT EXECUTED
   258bc:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
   258c0:	ebffffab 	bl	25774 <scanpw>                                 <== NOT EXECUTED
   258c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   258c8:	128400e0 	addne	r0, r4, #224	; 0xe0                         <== NOT EXECUTED
   258cc:	18bd8010 	popne	{r4, pc}                                    <== NOT EXECUTED
   258d0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
  return &pwent;                                                      
}                                                                     
   258d4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00025cb4 <getpwuid>: struct passwd *getpwuid( uid_t uid ) {
   25cb4:	e92d4003 	push	{r0, r1, lr}                                 <== NOT EXECUTED
  struct passwd *p;                                                   
                                                                      
  if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))                
   25cb8:	e59f1028 	ldr	r1, [pc, #40]	; 25ce8 <getpwuid+0x34>         <== NOT EXECUTED
}                                                                     
                                                                      
struct passwd *getpwuid(                                              
  uid_t uid                                                           
)                                                                     
{                                                                     
   25cbc:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
  struct passwd *p;                                                   
                                                                      
  if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))                
   25cc0:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
   25cc4:	e281201c 	add	r2, r1, #28                                   <== NOT EXECUTED
   25cc8:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
   25ccc:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
   25cd0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   25cd4:	ebffffe9 	bl	25c80 <getpwuid_r>                             <== NOT EXECUTED
   25cd8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   25cdc:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
    return NULL;                                                      
  return p;                                                           
   25ce0:	059d0004 	ldreq	r0, [sp, #4]                                <== NOT EXECUTED
}                                                                     
   25ce4:	e8bd800c 	pop	{r2, r3, pc}                                  <== NOT EXECUTED
                                                                      

00025c80 <getpwuid_r>: struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) {
   25c80:	e92d4003 	push	{r0, r1, lr}                                 <== NOT EXECUTED
   25c84:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
   25c88:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
  return getpw_r(NULL, uid, pwd, buffer, bufsize, result);            
   25c8c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  struct passwd  *pwd,                                                
  char           *buffer,                                             
  size_t          bufsize,                                            
  struct passwd **result                                              
)                                                                     
{                                                                     
   25c90:	e1a01800 	lsl	r1, r0, #16                                   <== NOT EXECUTED
  return getpw_r(NULL, uid, pwd, buffer, bufsize, result);            
   25c94:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
   25c98:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
   25c9c:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
   25ca0:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
   25ca4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   25ca8:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   25cac:	ebffffbf 	bl	25bb0 <getpw_r>                                <== NOT EXECUTED
}                                                                     
   25cb0:	e8bd800c 	pop	{r2, r3, pc}                                  <== NOT EXECUTED
                                                                      

00001f74 <gettimeofday>: */ int gettimeofday( struct timeval *tp, void * __tz __attribute__((unused)) ) {
    1f74:	e92d4033 	push	{r0, r1, r4, r5, lr}                         
  /* struct timezone* tzp = (struct timezone*) __tz; */               
  if ( !tp ) {                                                        
    1f78:	e2504000 	subs	r4, r0, #0                                   
    1f7c:	1a000004 	bne	1f94 <gettimeofday+0x20>                      
    errno = EFAULT;                                                   
    1f80:	eb002d0f 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1f84:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
    1f88:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1f8c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
    1f90:	ea00000c 	b	1fc8 <gettimeofday+0x54>                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    1f94:	e10f5000 	mrs	r5, CPSR                                      
    1f98:	e3853080 	orr	r3, r5, #128	; 0x80                           
    1f9c:	e129f003 	msr	CPSR_fc, r3                                   
  ISR_Level       level;                                              
  struct timespec now;                                                
  suseconds_t     useconds;                                           
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
    1fa0:	e1a0000d 	mov	r0, sp                                        
    1fa4:	eb000fae 	bl	5e64 <_TOD_Get>                                
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    1fa8:	e129f005 	msr	CPSR_fc, r5                                   
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
                                                                      
  time->tv_sec  = now.tv_sec;                                         
    1fac:	e59d3000 	ldr	r3, [sp]                                      
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
    1fb0:	e59d0004 	ldr	r0, [sp, #4]                                  
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
                                                                      
  time->tv_sec  = now.tv_sec;                                         
  time->tv_usec = useconds;                                           
    1fb4:	e3a01ffa 	mov	r1, #1000	; 0x3e8                             
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
                                                                      
  time->tv_sec  = now.tv_sec;                                         
    1fb8:	e5843000 	str	r3, [r4]                                      
  time->tv_usec = useconds;                                           
    1fbc:	eb0052ce 	bl	16afc <__aeabi_idiv>                           
    1fc0:	e5840004 	str	r0, [r4, #4]                                  
    1fc4:	e3a00000 	mov	r0, #0                                        
   *  with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X    
   *  do it.  This puts us in good company.                           
   */                                                                 
                                                                      
  return 0;                                                           
}                                                                     
    1fc8:	e8bd803c 	pop	{r2, r3, r4, r5, pc}                          
                                                                      

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

000052d0 <ioctl>: int ioctl( int fd, ioctl_command_t command, ... ) {
    52d0:	e92d000e 	push	{r1, r2, r3}                                 
  va_list            ap;                                              
  rtems_status_code  rc;                                              
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
    52d4:	e59f3080 	ldr	r3, [pc, #128]	; 535c <ioctl+0x8c>            
    52d8:	e5933000 	ldr	r3, [r3]                                      
    52dc:	e1500003 	cmp	r0, r3                                        
int ioctl(                                                            
  int  fd,                                                            
  ioctl_command_t  command,                                           
  ...                                                                 
)                                                                     
{                                                                     
    52e0:	e92d4001 	push	{r0, lr}                                     
  va_list            ap;                                              
  rtems_status_code  rc;                                              
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
    52e4:	2a00000b 	bcs	5318 <ioctl+0x48>                             
  iop = rtems_libio_iop( fd );                                        
    52e8:	e59f3070 	ldr	r3, [pc, #112]	; 5360 <ioctl+0x90>            
    52ec:	e5933000 	ldr	r3, [r3]                                      
    52f0:	e0830300 	add	r0, r3, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
    52f4:	e5903014 	ldr	r3, [r0, #20]                                 
    52f8:	e3130c01 	tst	r3, #256	; 0x100                              
    52fc:	0a000005 	beq	5318 <ioctl+0x48>                             
                                                                      
  /*                                                                  
   *  Now process the ioctl().                                        
   */                                                                 
                                                                      
  if ( !iop->handlers )                                               
    5300:	e590303c 	ldr	r3, [r0, #60]	; 0x3c                          
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
                                                                      
  va_start(ap, command);                                              
                                                                      
  buffer = va_arg(ap, void *);                                        
    5304:	e28d2010 	add	r2, sp, #16                                   
                                                                      
  /*                                                                  
   *  Now process the ioctl().                                        
   */                                                                 
                                                                      
  if ( !iop->handlers )                                               
    5308:	e3530000 	cmp	r3, #0                                        
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
                                                                      
  va_start(ap, command);                                              
                                                                      
  buffer = va_arg(ap, void *);                                        
    530c:	e58d2000 	str	r2, [sp]                                      
    5310:	e59d200c 	ldr	r2, [sp, #12]                                 
                                                                      
  /*                                                                  
   *  Now process the ioctl().                                        
   */                                                                 
                                                                      
  if ( !iop->handlers )                                               
    5314:	1a000002 	bne	5324 <ioctl+0x54>                             
    rtems_set_errno_and_return_minus_one( EBADF );                    
    5318:	eb003004 	bl	11330 <__errno>                                
    531c:	e3a03009 	mov	r3, #9                                        
    5320:	ea000004 	b	5338 <ioctl+0x68>                               
                                                                      
  if ( !iop->handlers->ioctl_h )                                      
    5324:	e5933010 	ldr	r3, [r3, #16]                                 
    5328:	e3530000 	cmp	r3, #0                                        
    532c:	1a000004 	bne	5344 <ioctl+0x74>                             
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    5330:	eb002ffe 	bl	11330 <__errno>                                <== NOT EXECUTED
    5334:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    5338:	e5803000 	str	r3, [r0]                                      
    533c:	e3e00000 	mvn	r0, #0                                        
    5340:	ea000002 	b	5350 <ioctl+0x80>                               
                                                                      
  rc = (*iop->handlers->ioctl_h)( iop, command, buffer );             
    5344:	e59d1008 	ldr	r1, [sp, #8]                                  
    5348:	e1a0e00f 	mov	lr, pc                                        
    534c:	e12fff13 	bx	r3                                             
                                                                      
  return rc;                                                          
}                                                                     
    5350:	e8bd4008 	pop	{r3, lr}                                      
    5354:	e28dd00c 	add	sp, sp, #12                                   
    5358:	e12fff1e 	bx	lr                                             
                                                                      

000037ec <iproc>: * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { if (tty->termios.c_iflag & ISTRIP)
    37ec:	e5913030 	ldr	r3, [r1, #48]	; 0x30                          <== NOT EXECUTED
    37f0:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
/*                                                                    
 * Process a single input character                                   
 */                                                                   
static int                                                            
iproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
    37f4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
    37f8:	e20050ff 	and	r5, r0, #255	; 0xff                           <== NOT EXECUTED
	if (tty->termios.c_iflag & ISTRIP)                                   
		c &= 0x7f;                                                          
    37fc:	1200507f 	andne	r5, r0, #127	; 0x7f                         <== NOT EXECUTED
	if (tty->termios.c_iflag & IUCLC)                                    
    3800:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
/*                                                                    
 * Process a single input character                                   
 */                                                                   
static int                                                            
iproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
    3804:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
	if (tty->termios.c_iflag & ISTRIP)                                   
		c &= 0x7f;                                                          
	if (tty->termios.c_iflag & IUCLC)                                    
    3808:	0a000007 	beq	382c <iproc+0x40>                             <== NOT EXECUTED
		c = tolower (c);                                                    
    380c:	e59f2164 	ldr	r2, [pc, #356]	; 3978 <iproc+0x18c>           <== NOT EXECUTED
    3810:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
    3814:	e0822005 	add	r2, r2, r5                                    <== NOT EXECUTED
    3818:	e5d22001 	ldrb	r2, [r2, #1]                                 <== NOT EXECUTED
    381c:	e2022003 	and	r2, r2, #3                                    <== NOT EXECUTED
    3820:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
    3824:	02855020 	addeq	r5, r5, #32                                 <== NOT EXECUTED
    3828:	e20550ff 	and	r5, r5, #255	; 0xff                           <== NOT EXECUTED
	if (c == '\r') {                                                     
    382c:	e355000d 	cmp	r5, #13                                       <== NOT EXECUTED
    3830:	1a000005 	bne	384c <iproc+0x60>                             <== NOT EXECUTED
		if (tty->termios.c_iflag & IGNCR)                                   
    3834:	e3130080 	tst	r3, #128	; 0x80                               <== NOT EXECUTED
    3838:	1a00004c 	bne	3970 <iproc+0x184>                            <== NOT EXECUTED
			return 0;                                                          
		if (tty->termios.c_iflag & ICRNL)                                   
    383c:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
    3840:	03a0500d 	moveq	r5, #13                                     <== NOT EXECUTED
    3844:	13a0500a 	movne	r5, #10                                     <== NOT EXECUTED
    3848:	ea000007 	b	386c <iproc+0x80>                               <== NOT EXECUTED
			c = '\n';                                                          
	}                                                                    
	else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {            
    384c:	e355000a 	cmp	r5, #10                                       <== NOT EXECUTED
    3850:	1a000003 	bne	3864 <iproc+0x78>                             <== NOT EXECUTED
    3854:	e3130040 	tst	r3, #64	; 0x40                                <== NOT EXECUTED
    3858:	03a0500a 	moveq	r5, #10                                     <== NOT EXECUTED
    385c:	13a0500d 	movne	r5, #13                                     <== NOT EXECUTED
    3860:	ea000001 	b	386c <iproc+0x80>                               <== NOT EXECUTED
		c = '\r';                                                           
	}                                                                    
	if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {                
    3864:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    3868:	0a00002e 	beq	3928 <iproc+0x13c>                            <== NOT EXECUTED
    386c:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
    3870:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
    3874:	0a00002b 	beq	3928 <iproc+0x13c>                            <== NOT EXECUTED
		if (c == tty->termios.c_cc[VERASE]) {                               
    3878:	e5d42043 	ldrb	r2, [r4, #67]	; 0x43                         <== NOT EXECUTED
    387c:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
			erase (tty, 0);                                                    
    3880:	01a00004 	moveq	r0, r4                                      <== NOT EXECUTED
    3884:	03a01000 	moveq	r1, #0                                      <== NOT EXECUTED
	}                                                                    
	else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {            
		c = '\r';                                                           
	}                                                                    
	if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {                
		if (c == tty->termios.c_cc[VERASE]) {                               
    3888:	0a000004 	beq	38a0 <iproc+0xb4>                             <== NOT EXECUTED
			erase (tty, 0);                                                    
			return 0;                                                          
		}                                                                   
		else if (c == tty->termios.c_cc[VKILL]) {                           
    388c:	e5d42044 	ldrb	r2, [r4, #68]	; 0x44                         <== NOT EXECUTED
    3890:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
    3894:	1a000003 	bne	38a8 <iproc+0xbc>                             <== NOT EXECUTED
			erase (tty, 1);                                                    
    3898:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    389c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    38a0:	ebffff5e 	bl	3620 <erase>                                   <== NOT EXECUTED
    38a4:	ea00002f 	b	3968 <iproc+0x17c>                              <== NOT EXECUTED
			return 0;                                                          
		}                                                                   
		else if (c == tty->termios.c_cc[VEOF]) {                            
    38a8:	e5d42045 	ldrb	r2, [r4, #69]	; 0x45                         <== NOT EXECUTED
    38ac:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
    38b0:	0a00001a 	beq	3920 <iproc+0x134>                            <== NOT EXECUTED
			return 1;                                                          
		}                                                                   
		else if (c == '\n') {                                               
    38b4:	e355000a 	cmp	r5, #10                                       <== NOT EXECUTED
    38b8:	1a000009 	bne	38e4 <iproc+0xf8>                             <== NOT EXECUTED
			if (tty->termios.c_lflag & (ECHO | ECHONL))                        
    38bc:	e3130048 	tst	r3, #72	; 0x48                                <== NOT EXECUTED
				echo (c, tty);                                                    
    38c0:	11a00005 	movne	r0, r5                                      <== NOT EXECUTED
    38c4:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
    38c8:	1bffff34 	blne	35a0 <echo>                                  <== NOT EXECUTED
			tty->cbuf[tty->ccount++] = c;                                      
    38cc:	e284101c 	add	r1, r4, #28                                   <== NOT EXECUTED
    38d0:	e891000a 	ldm	r1, {r1, r3}                                  <== NOT EXECUTED
    38d4:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
    38d8:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
    38dc:	e7c10003 	strb	r0, [r1, r3]                                 <== NOT EXECUTED
    38e0:	ea00000d 	b	391c <iproc+0x130>                              <== NOT EXECUTED
			return 1;                                                          
		}                                                                   
		else if ((c == tty->termios.c_cc[VEOL])                             
    38e4:	e5d4204c 	ldrb	r2, [r4, #76]	; 0x4c                         <== NOT EXECUTED
    38e8:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
    38ec:	0a000002 	beq	38fc <iproc+0x110>                            <== NOT EXECUTED
		      || (c == tty->termios.c_cc[VEOL2])) {                         
    38f0:	e5d42051 	ldrb	r2, [r4, #81]	; 0x51                         <== NOT EXECUTED
    38f4:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
    38f8:	1a00000a 	bne	3928 <iproc+0x13c>                            <== NOT EXECUTED
			if (tty->termios.c_lflag & ECHO)                                   
    38fc:	e3130008 	tst	r3, #8                                        <== NOT EXECUTED
				echo (c, tty);                                                    
    3900:	11a00005 	movne	r0, r5                                      <== NOT EXECUTED
    3904:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
    3908:	1bffff24 	blne	35a0 <echo>                                  <== NOT EXECUTED
			tty->cbuf[tty->ccount++] = c;                                      
    390c:	e284101c 	add	r1, r4, #28                                   <== NOT EXECUTED
    3910:	e891000a 	ldm	r1, {r1, r3}                                  <== NOT EXECUTED
    3914:	e7c15003 	strb	r5, [r1, r3]                                 <== NOT EXECUTED
    3918:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
    391c:	e5842020 	str	r2, [r4, #32]                                 <== NOT EXECUTED
    3920:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
			return 1;                                                          
    3924:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
	}                                                                    
                                                                      
	/*                                                                   
	 * FIXME: Should do IMAXBEL handling somehow                         
	 */                                                                  
	if (tty->ccount < (CBUFSIZE-1)) {                                    
    3928:	e59f304c 	ldr	r3, [pc, #76]	; 397c <iproc+0x190>            <== NOT EXECUTED
    392c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    3930:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
    3934:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    3938:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    393c:	aa00000b 	bge	3970 <iproc+0x184>                            <== NOT EXECUTED
		if (tty->termios.c_lflag & ECHO)                                    
    3940:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
    3944:	e3130008 	tst	r3, #8                                        <== NOT EXECUTED
			echo (c, tty);                                                     
    3948:	11a00005 	movne	r0, r5                                      <== NOT EXECUTED
    394c:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
    3950:	1bffff12 	blne	35a0 <echo>                                  <== NOT EXECUTED
		tty->cbuf[tty->ccount++] = c;                                       
    3954:	e284101c 	add	r1, r4, #28                                   <== NOT EXECUTED
    3958:	e891000a 	ldm	r1, {r1, r3}                                  <== NOT EXECUTED
    395c:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
    3960:	e7c15003 	strb	r5, [r1, r3]                                 <== NOT EXECUTED
    3964:	e5842020 	str	r2, [r4, #32]                                 <== NOT EXECUTED
    3968:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    396c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    3970:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
	}                                                                    
	return 0;                                                            
}                                                                     
    3974:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

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

00025d44 <link>: int link( const char *existing, const char *new ) {
   25d44:	e92d4070 	push	{r4, r5, r6, lr}                             
   25d48:	e24dd034 	sub	sp, sp, #52	; 0x34                            
   25d4c:	e1a05001 	mov	r5, r1                                        
   25d50:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   * Get the node we are linking to.                                  
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
   25d54:	eb007766 	bl	43af4 <strlen>                                 
   25d58:	e28d4018 	add	r4, sp, #24                                   
   25d5c:	e1a01000 	mov	r1, r0                                        
   25d60:	e3a0c001 	mov	ip, #1                                        
   25d64:	e1a00006 	mov	r0, r6                                        
   25d68:	e3a02000 	mov	r2, #0                                        
   25d6c:	e1a03004 	mov	r3, r4                                        
   25d70:	e58dc000 	str	ip, [sp]                                      
   25d74:	ebff8630 	bl	763c <rtems_filesystem_evaluate_path>          
                                           0, &existing_loc, true );  
  if ( result != 0 )                                                  
   25d78:	e3500000 	cmp	r0, #0                                        
   25d7c:	1a000014 	bne	25dd4 <link+0x90>                             
                                                                      
  /*                                                                  
   * Get the parent of the node we are creating.                      
   */                                                                 
                                                                      
  rtems_filesystem_get_start_loc( new, &i, &parent_loc );             
   25d80:	e28d6004 	add	r6, sp, #4                                    
   25d84:	e1a00005 	mov	r0, r5                                        
   25d88:	e28d1030 	add	r1, sp, #48	; 0x30                            
   25d8c:	e1a02006 	mov	r2, r6                                        
   25d90:	ebff8c62 	bl	8f20 <rtems_filesystem_get_start_loc>          
                                                                      
  if ( !parent_loc.ops->evalformake_h ) {                             
   25d94:	e59d3010 	ldr	r3, [sp, #16]                                 
   25d98:	e5933004 	ldr	r3, [r3, #4]                                  
   25d9c:	e3530000 	cmp	r3, #0                                        
   25da0:	1a00000d 	bne	25ddc <link+0x98>                             
    rtems_filesystem_freenode( &existing_loc );                       
   25da4:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   25da8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25dac:	0a000005 	beq	25dc8 <link+0x84>                             <== NOT EXECUTED
   25db0:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   25db4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25db8:	0a000002 	beq	25dc8 <link+0x84>                             <== NOT EXECUTED
   25dbc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   25dc0:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   25dc4:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   25dc8:	eb005c4c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   25dcc:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   25dd0:	e5803000 	str	r3, [r0]                                      
   25dd4:	e3e05000 	mvn	r5, #0                                        
   25dd8:	ea000053 	b	25f2c <link+0x1e8>                              
  }                                                                   
                                                                      
  result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
   25ddc:	e59d0030 	ldr	r0, [sp, #48]	; 0x30                          
   25de0:	e1a01006 	mov	r1, r6                                        
   25de4:	e0850000 	add	r0, r5, r0                                    
   25de8:	e28d202c 	add	r2, sp, #44	; 0x2c                            
   25dec:	e1a0e00f 	mov	lr, pc                                        
   25df0:	e12fff13 	bx	r3                                             
  if ( result != 0 ) {                                                
   25df4:	e2505000 	subs	r5, r0, #0                                   
   25df8:	0a00000a 	beq	25e28 <link+0xe4>                             
    rtems_filesystem_freenode( &existing_loc );                       
   25dfc:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
   25e00:	e3530000 	cmp	r3, #0                                        
   25e04:	0a000004 	beq	25e1c <link+0xd8>                             
   25e08:	e593301c 	ldr	r3, [r3, #28]                                 
   25e0c:	e3530000 	cmp	r3, #0                                        
   25e10:	11a00004 	movne	r0, r4                                      
   25e14:	11a0e00f 	movne	lr, pc                                      
   25e18:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( result );                   
   25e1c:	eb005c37 	bl	3cf00 <__errno>                                
   25e20:	e5805000 	str	r5, [r0]                                      
   25e24:	eaffffea 	b	25dd4 <link+0x90>                               
  /*                                                                  
   *  Check to see if the caller is trying to link across file system 
   *  boundaries.                                                     
   */                                                                 
                                                                      
  if ( parent_loc.mt_entry != existing_loc.mt_entry ) {               
   25e28:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          
   25e2c:	e59d2014 	ldr	r2, [sp, #20]                                 
   25e30:	e1520003 	cmp	r2, r3                                        
   25e34:	0a000012 	beq	25e84 <link+0x140>                            
    rtems_filesystem_freenode( &existing_loc );                       
   25e38:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
   25e3c:	e3530000 	cmp	r3, #0                                        
   25e40:	0a000004 	beq	25e58 <link+0x114>                            
   25e44:	e593301c 	ldr	r3, [r3, #28]                                 
   25e48:	e3530000 	cmp	r3, #0                                        
   25e4c:	11a00004 	movne	r0, r4                                      
   25e50:	11a0e00f 	movne	lr, pc                                      
   25e54:	112fff13 	bxne	r3                                           
    rtems_filesystem_freenode( &parent_loc );                         
   25e58:	e59d3010 	ldr	r3, [sp, #16]                                 
   25e5c:	e3530000 	cmp	r3, #0                                        
   25e60:	0a000004 	beq	25e78 <link+0x134>                            
   25e64:	e593301c 	ldr	r3, [r3, #28]                                 
   25e68:	e3530000 	cmp	r3, #0                                        
   25e6c:	128d0004 	addne	r0, sp, #4                                  
   25e70:	11a0e00f 	movne	lr, pc                                      
   25e74:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( EXDEV );                    
   25e78:	eb005c20 	bl	3cf00 <__errno>                                
   25e7c:	e3a03012 	mov	r3, #18                                       
   25e80:	eaffffd2 	b	25dd0 <link+0x8c>                               
  }                                                                   
                                                                      
  if ( !parent_loc.ops->link_h ) {                                    
   25e84:	e59d3010 	ldr	r3, [sp, #16]                                 
   25e88:	e5933008 	ldr	r3, [r3, #8]                                  
   25e8c:	e3530000 	cmp	r3, #0                                        
   25e90:	1a00000f 	bne	25ed4 <link+0x190>                            
    rtems_filesystem_freenode( &existing_loc );                       
   25e94:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   25e98:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25e9c:	0a000004 	beq	25eb4 <link+0x170>                            <== NOT EXECUTED
   25ea0:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   25ea4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25ea8:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   25eac:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   25eb0:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_filesystem_freenode( &parent_loc );                         
   25eb4:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   25eb8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25ebc:	0affffc1 	beq	25dc8 <link+0x84>                             <== NOT EXECUTED
   25ec0:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   25ec4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   25ec8:	128d0004 	addne	r0, sp, #4                                  <== NOT EXECUTED
   25ecc:	1affffbb 	bne	25dc0 <link+0x7c>                             <== NOT EXECUTED
   25ed0:	eaffffbc 	b	25dc8 <link+0x84>                               <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
   25ed4:	e1a01006 	mov	r1, r6                                        
   25ed8:	e1a00004 	mov	r0, r4                                        
   25edc:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          
   25ee0:	e1a0e00f 	mov	lr, pc                                        
   25ee4:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &existing_loc );                         
   25ee8:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
   25eec:	e3530000 	cmp	r3, #0                                        
    rtems_filesystem_freenode( &existing_loc );                       
    rtems_filesystem_freenode( &parent_loc );                         
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
   25ef0:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &existing_loc );                         
   25ef4:	0a000004 	beq	25f0c <link+0x1c8>                            
   25ef8:	e593301c 	ldr	r3, [r3, #28]                                 
   25efc:	e3530000 	cmp	r3, #0                                        
   25f00:	11a00004 	movne	r0, r4                                      
   25f04:	11a0e00f 	movne	lr, pc                                      
   25f08:	112fff13 	bxne	r3                                           
  rtems_filesystem_freenode( &parent_loc );                           
   25f0c:	e59d3010 	ldr	r3, [sp, #16]                                 
   25f10:	e3530000 	cmp	r3, #0                                        
   25f14:	0a000004 	beq	25f2c <link+0x1e8>                            
   25f18:	e593301c 	ldr	r3, [r3, #28]                                 
   25f1c:	e3530000 	cmp	r3, #0                                        
   25f20:	128d0004 	addne	r0, sp, #4                                  
   25f24:	11a0e00f 	movne	lr, pc                                      
   25f28:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
   25f2c:	e1a00005 	mov	r0, r5                                        
   25f30:	e28dd034 	add	sp, sp, #52	; 0x34                            
   25f34:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00018d98 <lseek>: { rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd );
   18d98:	e59fc0ec 	ldr	ip, [pc, #236]	; 18e8c <lseek+0xf4>           
   18d9c:	e59cc000 	ldr	ip, [ip]                                      
   18da0:	e150000c 	cmp	r0, ip                                        
off_t lseek(                                                          
  int     fd,                                                         
  off_t   offset,                                                     
  int     whence                                                      
)                                                                     
{                                                                     
   18da4:	e92d4870 	push	{r4, r5, r6, fp, lr}                         
  rtems_libio_t *iop;                                                 
  off_t          old_offset;                                          
  off_t          status;                                              
                                                                      
  rtems_libio_check_fd( fd );                                         
   18da8:	2a000005 	bcs	18dc4 <lseek+0x2c>                            
  iop = rtems_libio_iop( fd );                                        
   18dac:	e59fc0dc 	ldr	ip, [pc, #220]	; 18e90 <lseek+0xf8>           
   18db0:	e59c4000 	ldr	r4, [ip]                                      
   18db4:	e0844300 	add	r4, r4, r0, lsl #6                            
  rtems_libio_check_is_open(iop);                                     
   18db8:	e5940014 	ldr	r0, [r4, #20]                                 
   18dbc:	e3100c01 	tst	r0, #256	; 0x100                              
   18dc0:	1a000002 	bne	18dd0 <lseek+0x38>                            
   18dc4:	ebffd17e 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   18dc8:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   18dcc:	ea00001c 	b	18e44 <lseek+0xac>                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check as many errors as possible before touching iop->offset.   
   */                                                                 
                                                                      
  if ( !iop->handlers->lseek_h )                                      
   18dd0:	e594003c 	ldr	r0, [r4, #60]	; 0x3c                          
   18dd4:	e5900014 	ldr	r0, [r0, #20]                                 
   18dd8:	e3500000 	cmp	r0, #0                                        
   18ddc:	1a000002 	bne	18dec <lseek+0x54>                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   18de0:	ebffd177 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   18de4:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   18de8:	ea000015 	b	18e44 <lseek+0xac>                              <== NOT EXECUTED
  /*                                                                  
   *  Now process the lseek().                                        
   */                                                                 
                                                                      
  old_offset = iop->offset;                                           
  switch ( whence ) {                                                 
   18dec:	e3530001 	cmp	r3, #1                                        
                                                                      
  /*                                                                  
   *  Now process the lseek().                                        
   */                                                                 
                                                                      
  old_offset = iop->offset;                                           
   18df0:	e284600c 	add	r6, r4, #12                                   
   18df4:	e8960060 	ldm	r6, {r5, r6}                                  
  switch ( whence ) {                                                 
   18df8:	0a000006 	beq	18e18 <lseek+0x80>                            
   18dfc:	e3530002 	cmp	r3, #2                                        
   18e00:	0a000007 	beq	18e24 <lseek+0x8c>                            
   18e04:	e3530000 	cmp	r3, #0                                        
   18e08:	1a00000b 	bne	18e3c <lseek+0xa4>                            
    case SEEK_SET:                                                    
      iop->offset = offset;                                           
   18e0c:	e584100c 	str	r1, [r4, #12]                                 
   18e10:	e5842010 	str	r2, [r4, #16]                                 
      break;                                                          
   18e14:	ea00000e 	b	18e54 <lseek+0xbc>                              
                                                                      
    case SEEK_CUR:                                                    
      iop->offset += offset;                                          
   18e18:	e091b005 	adds	fp, r1, r5                                   
   18e1c:	e0a2c006 	adc	ip, r2, r6                                    
   18e20:	ea000002 	b	18e30 <lseek+0x98>                              
      break;                                                          
                                                                      
    case SEEK_END:                                                    
      iop->offset = iop->size + offset;                               
   18e24:	e9941800 	ldmib	r4, {fp, ip}                                
   18e28:	e09bb001 	adds	fp, fp, r1                                   
   18e2c:	e0acc002 	adc	ip, ip, r2                                    
   18e30:	e584b00c 	str	fp, [r4, #12]                                 
   18e34:	e584c010 	str	ip, [r4, #16]                                 
      break;                                                          
   18e38:	ea000005 	b	18e54 <lseek+0xbc>                              
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
   18e3c:	ebffd160 	bl	d3c4 <__errno>                                 
   18e40:	e3a03016 	mov	r3, #22                                       
   18e44:	e5803000 	str	r3, [r0]                                      
   18e48:	e3e02000 	mvn	r2, #0                                        
   18e4c:	e3e03000 	mvn	r3, #0                                        
   18e50:	ea00000a 	b	18e80 <lseek+0xe8>                              
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->handlers->lseek_h)( iop, offset, whence );          
   18e54:	e594c03c 	ldr	ip, [r4, #60]	; 0x3c                          
   18e58:	e1a00004 	mov	r0, r4                                        
   18e5c:	e1a0e00f 	mov	lr, pc                                        
   18e60:	e59cf014 	ldr	pc, [ip, #20]                                 
  if ( status == (off_t) -1 )                                         
   18e64:	e3700001 	cmn	r0, #1                                        
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->handlers->lseek_h)( iop, offset, whence );          
   18e68:	e1a02000 	mov	r2, r0                                        
   18e6c:	e1a03001 	mov	r3, r1                                        
  if ( status == (off_t) -1 )                                         
   18e70:	1a000002 	bne	18e80 <lseek+0xe8>                            
   18e74:	e3710001 	cmn	r1, #1                                        
    iop->offset = old_offset;                                         
   18e78:	0584500c 	streq	r5, [r4, #12]                               
   18e7c:	05846010 	streq	r6, [r4, #16]                               
  /*                                                                  
   *  So if the operation failed, we have to restore iop->offset.     
   */                                                                 
                                                                      
  return status;                                                      
}                                                                     
   18e80:	e1a01003 	mov	r1, r3                                        
   18e84:	e1a00002 	mov	r0, r2                                        
   18e88:	e8bd8870 	pop	{r4, r5, r6, fp, pc}                          
                                                                      

00026054 <lstat>: int _STAT_NAME( const char *path, struct stat *buf ) {
   26054:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
   26058:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
int _STAT_NAME(                                                       
  const char  *path,                                                  
  struct stat *buf                                                    
)                                                                     
{                                                                     
   2605c:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
   26060:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
   26064:	1a000002 	bne	26074 <lstat+0x20>                            <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
   26068:	eb005ba4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   2606c:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
   26070:	ea000018 	b	260d8 <lstat+0x84>                              <== NOT EXECUTED
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ),      
   26074:	eb00769e 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   26078:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
   2607c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   26080:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   26084:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
   26088:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   2608c:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   26090:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   26094:	ebff8568 	bl	763c <rtems_filesystem_evaluate_path>          <== NOT EXECUTED
                                           0, &loc, _STAT_FOLLOW_LINKS );
  if ( status != 0 )                                                  
   26098:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   2609c:	1a00000e 	bne	260dc <lstat+0x88>                            <== NOT EXECUTED
    return -1;                                                        
                                                                      
  if ( !loc.handlers->fstat_h ){                                      
   260a0:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   260a4:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
   260a8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   260ac:	1a00000c 	bne	260e4 <lstat+0x90>                            <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
   260b0:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   260b4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   260b8:	0a000004 	beq	260d0 <lstat+0x7c>                            <== NOT EXECUTED
   260bc:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   260c0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   260c4:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   260c8:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   260cc:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   260d0:	eb005b8a 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   260d4:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   260d8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   260dc:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   260e0:	ea000010 	b	26128 <lstat+0xd4>                              <== NOT EXECUTED
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
   260e4:	e3a02048 	mov	r2, #72	; 0x48                                <== NOT EXECUTED
   260e8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   260ec:	eb0068ba 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
   260f0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   260f4:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   260f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   260fc:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   26100:	e593f018 	ldr	pc, [r3, #24]                                 <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26104:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   26108:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
   2610c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26110:	0a000004 	beq	26128 <lstat+0xd4>                            <== NOT EXECUTED
   26114:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   26118:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   2611c:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   26120:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   26124:	112fff13 	bxne	r3                                           <== NOT EXECUTED
                                                                      
  return status;                                                      
}                                                                     
   26128:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   2612c:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
   26130:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00002200 <malloc>: size_t size ) { void *return_this; MSBUMP(malloc_calls, 1);
    2200:	e59f30d8 	ldr	r3, [pc, #216]	; 22e0 <malloc+0xe0>           
    2204:	e5932004 	ldr	r2, [r3, #4]                                  
    2208:	e2822001 	add	r2, r2, #1                                    
    220c:	e92d4070 	push	{r4, r5, r6, lr}                             
    2210:	e5832004 	str	r2, [r3, #4]                                  
    2214:	e1a04000 	mov	r4, r0                                        
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
    2218:	ebffffb5 	bl	20f4 <malloc_deferred_frees_process>           
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
    221c:	e3540000 	cmp	r4, #0                                        
    2220:	0a00002b 	beq	22d4 <malloc+0xd4>                            
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
    2224:	e59f30b8 	ldr	r3, [pc, #184]	; 22e4 <malloc+0xe4>           
    2228:	e5933000 	ldr	r3, [r3]                                      
    222c:	e3530003 	cmp	r3, #3                                        
    2230:	1a000002 	bne	2240 <malloc+0x40>                            
    2234:	ebffff97 	bl	2098 <malloc_is_system_state_OK>               
    2238:	e3500000 	cmp	r0, #0                                        
    223c:	0a000024 	beq	22d4 <malloc+0xd4>                            
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(                  
  Heap_Control *heap,                                                 
  uintptr_t size                                                      
)                                                                     
{                                                                     
  return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
    2240:	e59f30a0 	ldr	r3, [pc, #160]	; 22e8 <malloc+0xe8>           
    2244:	e3a02000 	mov	r2, #0                                        
    2248:	e5930000 	ldr	r0, [r3]                                      
    224c:	e1a01004 	mov	r1, r4                                        
    2250:	e1a03002 	mov	r3, r2                                        
    2254:	eb0011ff 	bl	6a58 <_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 ) {                                               
    2258:	e2506000 	subs	r6, r0, #0                                   
    if (rtems_malloc_sbrk_helpers)                                    
      return_this = (*rtems_malloc_sbrk_helpers->extend)( size );     
    if ( !return_this ) {                                             
      errno = ENOMEM;                                                 
      return (void *) 0;                                              
    225c:	11a05006 	movne	r5, r6                                      
   * If this fails then return a NULL pointer.                        
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
                                                                      
  if ( !return_this ) {                                               
    2260:	1a00000c 	bne	2298 <malloc+0x98>                            
    if (rtems_malloc_sbrk_helpers)                                    
    2264:	e59f3080 	ldr	r3, [pc, #128]	; 22ec <malloc+0xec>           
    2268:	e5933000 	ldr	r3, [r3]                                      
    226c:	e3530000 	cmp	r3, #0                                        
    2270:	0a000004 	beq	2288 <malloc+0x88>                            
      return_this = (*rtems_malloc_sbrk_helpers->extend)( size );     
    2274:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    2278:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    227c:	e593f004 	ldr	pc, [r3, #4]                                  <== NOT EXECUTED
    if ( !return_this ) {                                             
    2280:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
    2284:	1a000003 	bne	2298 <malloc+0x98>                            <== NOT EXECUTED
      errno = ENOMEM;                                                 
    2288:	eb002c4d 	bl	d3c4 <__errno>                                 
    228c:	e3a0300c 	mov	r3, #12                                       
    2290:	e5803000 	str	r3, [r0]                                      
      return (void *) 0;                                              
    2294:	ea00000f 	b	22d8 <malloc+0xd8>                              
  }                                                                   
                                                                      
  /*                                                                  
   *  If the user wants us to dirty the allocated memory, then do it. 
   */                                                                 
  if ( rtems_malloc_dirty_helper )                                    
    2298:	e59f3050 	ldr	r3, [pc, #80]	; 22f0 <malloc+0xf0>            
    229c:	e5933000 	ldr	r3, [r3]                                      
    22a0:	e3530000 	cmp	r3, #0                                        
    (*rtems_malloc_dirty_helper)( return_this, size );                
    22a4:	11a01004 	movne	r1, r4                                      
    22a8:	11a00005 	movne	r0, r5                                      
    22ac:	11a0e00f 	movne	lr, pc                                      
    22b0:	112fff13 	bxne	r3                                           
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
    22b4:	e59f3038 	ldr	r3, [pc, #56]	; 22f4 <malloc+0xf4>            
    22b8:	e5933000 	ldr	r3, [r3]                                      
    22bc:	e3530000 	cmp	r3, #0                                        
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
    22c0:	11a00005 	movne	r0, r5                                      
    22c4:	11a0e00f 	movne	lr, pc                                      
    22c8:	1593f004 	ldrne	pc, [r3, #4]                                
    22cc:	e1a06005 	mov	r6, r5                                        
    22d0:	ea000000 	b	22d8 <malloc+0xd8>                              
    22d4:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
    if (rtems_malloc_boundary_helpers)                                
      (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); 
  #endif                                                              
                                                                      
  return return_this;                                                 
}                                                                     
    22d8:	e1a00006 	mov	r0, r6                                        
    22dc:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

000020e4 <malloc_deferred_free>: } void malloc_deferred_free( void *pointer ) {
    20e4:	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 );                               
    20e8:	e59f0000 	ldr	r0, [pc, #0]	; 20f0 <malloc_deferred_free+0xc><== NOT EXECUTED
    20ec:	ea000e55 	b	5a48 <_Chain_Append>                            <== NOT EXECUTED
                                                                      

000020f4 <malloc_deferred_frees_process>: { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) {
    20f4:	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)
    20f8:	ea000000 	b	2100 <malloc_deferred_frees_process+0xc>        
    free(to_be_freed);                                                
    20fc:	ebffff73 	bl	1ed0 <free>                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
    2100:	e59f000c 	ldr	r0, [pc, #12]	; 2114 <malloc_deferred_frees_process+0x20>
    2104:	eb000e63 	bl	5a98 <_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)
    2108:	e3500000 	cmp	r0, #0                                        
    210c:	1afffffa 	bne	20fc <malloc_deferred_frees_process+0x8>      
    free(to_be_freed);                                                
}                                                                     
    2110:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

0000beac <memfile_ftruncate>: int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) {
    beac:	e92d4013 	push	{r0, r1, r4, lr}                             
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->file_info;                                         
    beb0:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          
   *  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 )                           
    beb4:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          
    beb8:	e1530002 	cmp	r3, r2                                        
    bebc:	ba000003 	blt	bed0 <memfile_ftruncate+0x24>                 
    bec0:	1a000005 	bne	bedc <memfile_ftruncate+0x30>                 
    bec4:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          
    bec8:	e1530001 	cmp	r3, r1                                        
    becc:	2a000002 	bcs	bedc <memfile_ftruncate+0x30>                 
    return IMFS_memfile_extend( the_jnode, length );                  
    bed0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    bed4:	ebffff9a 	bl	bd44 <IMFS_memfile_extend>                     <== NOT EXECUTED
    bed8:	ea000008 	b	bf00 <memfile_ftruncate+0x54>                   <== 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;                                 
    bedc:	e5841050 	str	r1, [r4, #80]	; 0x50                          
    bee0:	e5842054 	str	r2, [r4, #84]	; 0x54                          
  iop->size = the_jnode->info.file.size;                              
    bee4:	e9800006 	stmib	r0, {r1, r2}                                
                                                                      
  IMFS_update_atime( the_jnode );                                     
    bee8:	e3a01000 	mov	r1, #0                                        
    beec:	e1a0000d 	mov	r0, sp                                        
    bef0:	ebffd81f 	bl	1f74 <gettimeofday>                            
    bef4:	e59d3000 	ldr	r3, [sp]                                      
    bef8:	e5843040 	str	r3, [r4, #64]	; 0x40                          
    befc:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
}                                                                     
    bf00:	e8bd801c 	pop	{r2, r3, r4, pc}                              
                                                                      

0000bf04 <memfile_lseek>: rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) {
    bf04:	e92d4030 	push	{r4, r5, lr}                                 
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->file_info;                                         
    bf08:	e5905038 	ldr	r5, [r0, #56]	; 0x38                          
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    bf0c:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
    bf10:	e3530006 	cmp	r3, #6                                        
rtems_off64_t memfile_lseek(                                          
  rtems_libio_t   *iop,                                               
  rtems_off64_t    offset,                                            
  int              whence                                             
)                                                                     
{                                                                     
    bf14:	e1a04000 	mov	r4, r0                                        
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->file_info;                                         
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    bf18:	1a00000b 	bne	bf4c <memfile_lseek+0x48>                     
    if (iop->offset > the_jnode->info.linearfile.size)                
    bf1c:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
    bf20:	e5953054 	ldr	r3, [r5, #84]	; 0x54                          <== NOT EXECUTED
    bf24:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    bf28:	e5952050 	ldr	r2, [r5, #80]	; 0x50                          <== NOT EXECUTED
    bf2c:	ca000003 	bgt	bf40 <memfile_lseek+0x3c>                     <== NOT EXECUTED
    bf30:	1a000014 	bne	bf88 <memfile_lseek+0x84>                     <== NOT EXECUTED
    bf34:	e590100c 	ldr	r1, [r0, #12]                                 <== NOT EXECUTED
    bf38:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    bf3c:	9a000011 	bls	bf88 <memfile_lseek+0x84>                     <== NOT EXECUTED
      iop->offset = the_jnode->info.linearfile.size;                  
    bf40:	e584200c 	str	r2, [r4, #12]                                 <== NOT EXECUTED
    bf44:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
    bf48:	ea00000e 	b	bf88 <memfile_lseek+0x84>                       <== NOT EXECUTED
  }                                                                   
  else {  /* Must be a block file (IMFS_MEMORY_FILE). */              
    if (IMFS_memfile_extend( the_jnode, iop->offset ))                
    bf4c:	e1a00005 	mov	r0, r5                                        
    bf50:	e284200c 	add	r2, r4, #12                                   
    bf54:	e8920006 	ldm	r2, {r1, r2}                                  
    bf58:	ebffff79 	bl	bd44 <IMFS_memfile_extend>                     
    bf5c:	e3500000 	cmp	r0, #0                                        
    bf60:	0a000005 	beq	bf7c <memfile_lseek+0x78>                     
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
    bf64:	eb000516 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    bf68:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
    bf6c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    bf70:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
    bf74:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
    bf78:	ea000004 	b	bf90 <memfile_lseek+0x8c>                       <== NOT EXECUTED
                                                                      
    iop->size = the_jnode->info.file.size;                            
    bf7c:	e2853050 	add	r3, r5, #80	; 0x50                            
    bf80:	e893000c 	ldm	r3, {r2, r3}                                  
    bf84:	e984000c 	stmib	r4, {r2, r3}                                
  }                                                                   
  return iop->offset;                                                 
    bf88:	e284400c 	add	r4, r4, #12                                   
    bf8c:	e8940018 	ldm	r4, {r3, r4}                                  
}                                                                     
    bf90:	e1a01004 	mov	r1, r4                                        
    bf94:	e1a00003 	mov	r0, r3                                        
    bf98:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

0000c228 <memfile_open>: the_jnode = iop->file_info; /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
    c228:	e5903014 	ldr	r3, [r0, #20]                                 
    c22c:	e3130f81 	tst	r3, #516	; 0x204                              
  rtems_libio_t *iop,                                                 
  const char    *pathname,                                            
  uint32_t       flag,                                                
  uint32_t       mode                                                 
)                                                                     
{                                                                     
    c230:	e92d4031 	push	{r0, r4, r5, lr}                             
    c234:	e1a05000 	mov	r5, r0                                        
  IMFS_jnode_t  *the_jnode;                                           
                                                                      
  the_jnode = iop->file_info;                                         
    c238:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
    c23c:	0a000017 	beq	c2a0 <memfile_open+0x78>                      
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
    c240:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          
    c244:	e3530006 	cmp	r3, #6                                        
    c248:	1a000014 	bne	c2a0 <memfile_open+0x78>                      
    uint32_t   count = the_jnode->info.linearfile.size;               
    c24c:	e594c050 	ldr	ip, [r4, #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;                         
    c250:	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;                               
    c254:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
    c258:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    c25c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    the_jnode->info.file.indirect        = 0;                         
    the_jnode->info.file.doubly_indirect = 0;                         
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
    c260:	e35c0000 	cmp	ip, #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;                               
    c264:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== 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;                         
    c268:	e5842060 	str	r2, [r4, #96]	; 0x60                          <== 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;  
    c26c:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    the_jnode->type = IMFS_MEMORY_FILE;                               
    the_jnode->info.file.size            = 0;                         
    c270:	e5840050 	str	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
    c274:	e5841054 	str	r1, [r4, #84]	; 0x54                          <== NOT EXECUTED
    the_jnode->info.file.indirect        = 0;                         
    the_jnode->info.file.doubly_indirect = 0;                         
    c278:	e584205c 	str	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    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;                         
    the_jnode->info.file.indirect        = 0;                         
    c27c:	e5842058 	str	r2, [r4, #88]	; 0x58                          <== NOT EXECUTED
    the_jnode->info.file.doubly_indirect = 0;                         
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
    c280:	0a000006 	beq	c2a0 <memfile_open+0x78>                      <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
    c284:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    c288:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
    c28c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    c290:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
    c294:	ebffff40 	bl	bf9c <IMFS_memfile_write>                      <== NOT EXECUTED
    the_jnode->type = IMFS_MEMORY_FILE;                               
    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)                                                  
    c298:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
    c29c:	0a000009 	beq	c2c8 <memfile_open+0xa0>                      <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
        return -1;                                                    
  }                                                                   
  if (iop->flags & LIBIO_FLAGS_APPEND)                                
    c2a0:	e5953014 	ldr	r3, [r5, #20]                                 
    c2a4:	e3130c02 	tst	r3, #512	; 0x200                              
    iop->offset = the_jnode->info.file.size;                          
    c2a8:	12843050 	addne	r3, r4, #80	; 0x50                          
    c2ac:	1893000c 	ldmne	r3, {r2, r3}                                
    c2b0:	1585200c 	strne	r2, [r5, #12]                               
    c2b4:	15853010 	strne	r3, [r5, #16]                               
                                                                      
  iop->size = the_jnode->info.file.size;                              
    c2b8:	e2844050 	add	r4, r4, #80	; 0x50                            
    c2bc:	e8940018 	ldm	r4, {r3, r4}                                  
    c2c0:	e9850018 	stmib	r5, {r3, r4}                                
    c2c4:	e3a00000 	mov	r0, #0                                        
  return 0;                                                           
}                                                                     
    c2c8:	e8bd8038 	pop	{r3, r4, r5, pc}                              
                                                                      

00002308 <mknod>: int mknod( const char *pathname, mode_t mode, dev_t dev ) {
    2308:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
    230c:	e1a05001 	mov	r5, r1                                        
  int                                 result;                         
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & S_IFMT)                                              
    2310:	e2011a0f 	and	r1, r1, #61440	; 0xf000                       
    2314:	e3510901 	cmp	r1, #16384	; 0x4000                           
int mknod(                                                            
  const char *pathname,                                               
  mode_t      mode,                                                   
  dev_t       dev                                                     
)                                                                     
{                                                                     
    2318:	e24dd020 	sub	sp, sp, #32                                   
    231c:	e1a06000 	mov	r6, r0                                        
    2320:	e1a07002 	mov	r7, r2                                        
    2324:	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)                                              
    2328:	0a00000b 	beq	235c <mknod+0x54>                             
    232c:	8a000003 	bhi	2340 <mknod+0x38>                             
    2330:	e3510a01 	cmp	r1, #4096	; 0x1000                            
    2334:	0a000008 	beq	235c <mknod+0x54>                             
    2338:	e3510a02 	cmp	r1, #8192	; 0x2000                            
    233c:	ea000002 	b	234c <mknod+0x44>                               
    2340:	e3510a06 	cmp	r1, #24576	; 0x6000                           
    2344:	0a000004 	beq	235c <mknod+0x54>                             
    2348:	e3510902 	cmp	r1, #32768	; 0x8000                           
    234c:	0a000002 	beq	235c <mknod+0x54>                             
    case S_IFBLK:                                                     
    case S_IFREG:                                                     
    case S_IFIFO:                                                     
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    2350:	eb002c1b 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    2354:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    2358:	ea00000a 	b	2388 <mknod+0x80>                               <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );          
    235c:	e28d4004 	add	r4, sp, #4                                    
    2360:	e1a00006 	mov	r0, r6                                        
    2364:	e28d101c 	add	r1, sp, #28                                   
    2368:	e1a02004 	mov	r2, r4                                        
    236c:	eb000275 	bl	2d48 <rtems_filesystem_get_start_loc>          
                                                                      
  if ( !temp_loc.ops->evalformake_h ) {                               
    2370:	e59d3010 	ldr	r3, [sp, #16]                                 
    2374:	e5933004 	ldr	r3, [r3, #4]                                  
    2378:	e3530000 	cmp	r3, #0                                        
    237c:	1a000004 	bne	2394 <mknod+0x8c>                             
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    2380:	eb002c0f 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    2384:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    2388:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    238c:	e3e05000 	mvn	r5, #0                                        
    2390:	ea000022 	b	2420 <mknod+0x118>                              
  }                                                                   
                                                                      
  result = (*temp_loc.ops->evalformake_h)(                            
    2394:	e59d001c 	ldr	r0, [sp, #28]                                 
    2398:	e1a01004 	mov	r1, r4                                        
    239c:	e0860000 	add	r0, r6, r0                                    
    23a0:	e28d2018 	add	r2, sp, #24                                   
    23a4:	e1a0e00f 	mov	lr, pc                                        
    23a8:	e12fff13 	bx	r3                                             
    &pathname[i],                                                     
    &temp_loc,                                                        
    &name_start                                                       
  );                                                                  
  if ( result != 0 )                                                  
    23ac:	e3500000 	cmp	r0, #0                                        
    23b0:	1afffff5 	bne	238c <mknod+0x84>                             
    return -1;                                                        
                                                                      
  if ( !temp_loc.ops->mknod_h ) {                                     
    23b4:	e59d3010 	ldr	r3, [sp, #16]                                 
    23b8:	e593c014 	ldr	ip, [r3, #20]                                 
    23bc:	e35c0000 	cmp	ip, #0                                        
    23c0:	1a000006 	bne	23e0 <mknod+0xd8>                             
    rtems_filesystem_freenode( &temp_loc );                           
    23c4:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    23c8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    23cc:	0affffeb 	beq	2380 <mknod+0x78>                             <== NOT EXECUTED
    23d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    23d4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    23d8:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    23dc:	eaffffe7 	b	2380 <mknod+0x78>                               <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result =  (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
    23e0:	e1a01005 	mov	r1, r5                                        
    23e4:	e1a03008 	mov	r3, r8                                        
    23e8:	e58d4000 	str	r4, [sp]                                      
    23ec:	e1a02007 	mov	r2, r7                                        
    23f0:	e59d0018 	ldr	r0, [sp, #24]                                 
    23f4:	e1a0e00f 	mov	lr, pc                                        
    23f8:	e12fff1c 	bx	ip                                             
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
    23fc:	e59d3010 	ldr	r3, [sp, #16]                                 
    2400:	e3530000 	cmp	r3, #0                                        
  if ( !temp_loc.ops->mknod_h ) {                                     
    rtems_filesystem_freenode( &temp_loc );                           
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result =  (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
    2404:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
    2408:	0a000004 	beq	2420 <mknod+0x118>                            
    240c:	e593301c 	ldr	r3, [r3, #28]                                 
    2410:	e3530000 	cmp	r3, #0                                        
    2414:	11a00004 	movne	r0, r4                                      
    2418:	11a0e00f 	movne	lr, pc                                      
    241c:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
    2420:	e1a00005 	mov	r0, r5                                        
    2424:	e28dd020 	add	sp, sp, #32                                   
    2428:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

000024b4 <mount>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
    24b4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
                                                                      
  /*                                                                  
   *  Are the file system options valid?                              
   */                                                                 
                                                                      
  if ( options != RTEMS_FILESYSTEM_READ_ONLY &&                       
    24b8:	e3530001 	cmp	r3, #1                                        
  const char                 *target,                                 
  const char                 *filesystemtype,                         
  rtems_filesystem_options_t options,                                 
  const void                 *data                                    
)                                                                     
{                                                                     
    24bc:	e24dd028 	sub	sp, sp, #40	; 0x28                            
    24c0:	e58d300c 	str	r3, [sp, #12]                                 
    24c4:	e1a08000 	mov	r8, r0                                        
    24c8:	e1a07001 	mov	r7, r1                                        
    24cc:	e1a0b002 	mov	fp, r2                                        
                                                                      
  /*                                                                  
   *  Are the file system options valid?                              
   */                                                                 
                                                                      
  if ( options != RTEMS_FILESYSTEM_READ_ONLY &&                       
    24d0:	8a000004 	bhi	24e8 <mount+0x34>                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  /*                                                                  
   *  Get mount handler                                               
   */                                                                 
  mount_h = rtems_filesystem_get_mount_handler( filesystemtype );     
    24d4:	e1a00002 	mov	r0, r2                                        
    24d8:	eb002048 	bl	a600 <rtems_filesystem_get_mount_handler>      
  if ( !mount_h )                                                     
    24dc:	e3500000 	cmp	r0, #0                                        
    24e0:	e58d0010 	str	r0, [sp, #16]                                 
    24e4:	1a000002 	bne	24f4 <mount+0x40>                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    24e8:	eb002bb5 	bl	d3c4 <__errno>                                 
    24ec:	e3a03016 	mov	r3, #22                                       
    24f0:	ea000039 	b	25dc <mount+0x128>                              
{                                                                     
  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;                                   
    24f4:	e2575000 	subs	r5, r7, #0                                   
    24f8:	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 : "/"; 
    24fc:	e59f32ac 	ldr	r3, [pc, #684]	; 27b0 <mount+0x2fc>           
    2500:	e3550000 	cmp	r5, #0                                        
    2504:	11a03007 	movne	r3, r7                                      
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
    2508:	e1a0000b 	mov	r0, fp                                        
  const char *target_or_null,                                         
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
    250c:	e58d3004 	str	r3, [sp, #4]                                  
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
    2510:	eb002fb0 	bl	e3d8 <strlen>                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
    2514:	e3580000 	cmp	r8, #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;          
    2518:	e2806001 	add	r6, r0, #1                                    
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
    251c:	01a0a008 	moveq	sl, r8                                      
    2520:	0a000002 	beq	2530 <mount+0x7c>                             
    2524:	e1a00008 	mov	r0, r8                                        
    2528:	eb002faa 	bl	e3d8 <strlen>                                  
    252c:	e280a001 	add	sl, r0, #1                                    
  size_t target_length = strlen( target );                            
    2530:	e59d0004 	ldr	r0, [sp, #4]                                  
    2534:	eb002fa7 	bl	e3d8 <strlen>                                  
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_length + 1;          
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
    2538:	e2861075 	add	r1, r6, #117	; 0x75                           
    253c:	e0811000 	add	r1, r1, r0                                    
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
  size_t target_length = strlen( target );                            
    2540:	e58d0008 	str	r0, [sp, #8]                                  
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_length + 1;          
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
    2544:	e081100a 	add	r1, r1, sl                                    
    2548:	e3a00001 	mov	r0, #1                                        
    254c:	ebfffdd7 	bl	1cb0 <calloc>                                  
                                                                      
  if ( mt_entry != NULL ) {                                           
    2550:	e2504000 	subs	r4, r0, #0                                   
    2554:	0a00001e 	beq	25d4 <mount+0x120>                            
    char *str = (char *) mt_entry + sizeof( *mt_entry );              
    2558:	e2849074 	add	r9, r4, #116	; 0x74                           
                                                                      
    strcpy( str, filesystemtype );                                    
    255c:	e1a0100b 	mov	r1, fp                                        
    2560:	e1a00009 	mov	r0, r9                                        
    2564:	eb002f4b 	bl	e298 <strcpy>                                  
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    if ( source_or_null != NULL ) {                                   
    2568:	e3580000 	cmp	r8, #0                                        
  if ( mt_entry != NULL ) {                                           
    char *str = (char *) mt_entry + sizeof( *mt_entry );              
                                                                      
    strcpy( str, filesystemtype );                                    
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
    256c:	e0896006 	add	r6, r9, r6                                    
                                                                      
  if ( mt_entry != NULL ) {                                           
    char *str = (char *) mt_entry + sizeof( *mt_entry );              
                                                                      
    strcpy( str, filesystemtype );                                    
    mt_entry->type = str;                                             
    2570:	e584906c 	str	r9, [r4, #108]	; 0x6c                         
    str += filesystemtype_size;                                       
                                                                      
    if ( source_or_null != NULL ) {                                   
    2574:	0a000004 	beq	258c <mount+0xd8>                             
      strcpy( str, source_or_null );                                  
    2578:	e1a00006 	mov	r0, r6                                        
    257c:	e1a01008 	mov	r1, r8                                        
    2580:	eb002f44 	bl	e298 <strcpy>                                  
      mt_entry->dev = str;                                            
    2584:	e5846070 	str	r6, [r4, #112]	; 0x70                         
      str += source_size;                                             
    2588:	e086600a 	add	r6, r6, sl                                    
    }                                                                 
                                                                      
    strcpy( str, target );                                            
    258c:	e59d1004 	ldr	r1, [sp, #4]                                  
    2590:	e1a00006 	mov	r0, r6                                        
    2594:	eb002f3f 	bl	e298 <strcpy>                                  
  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;
    2598:	e59fe214 	ldr	lr, [pc, #532]	; 27b4 <mount+0x300>           
    259c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    25a0:	e284c038 	add	ip, r4, #56	; 0x38                            
    25a4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    25a8:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    25ac:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    25b0:	e89e000f 	ldm	lr, {r0, r1, r2, r3}                          
    25b4:	e88c000f 	stm	ip, {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;                                        
    25b8:	e59d300c 	ldr	r3, [sp, #12]                                 
  /*                                                                  
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( has_target ) {                                                 
    25bc:	e3550000 	cmp	r5, #0                                        
      mt_entry->dev = str;                                            
      str += source_size;                                             
    }                                                                 
                                                                      
    strcpy( str, target );                                            
    mt_entry->target = str;                                           
    25c0:	e5846068 	str	r6, [r4, #104]	; 0x68                         
  );                                                                  
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  mt_entry->mt_fs_root.mt_entry = mt_entry;                           
  mt_entry->options = options;                                        
    25c4:	e5843030 	str	r3, [r4, #48]	; 0x30                          
    &target_length                                                    
  );                                                                  
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  mt_entry->mt_fs_root.mt_entry = mt_entry;                           
    25c8:	e584402c 	str	r4, [r4, #44]	; 0x2c                          
  /*                                                                  
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( has_target ) {                                                 
    25cc:	0a000037 	beq	26b0 <mount+0x1fc>                            
    25d0:	ea000003 	b	25e4 <mount+0x130>                              
    target,                                                           
    filesystemtype,                                                   
    &target_length                                                    
  );                                                                  
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
    25d4:	eb002b7a 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    25d8:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    25dc:	e5803000 	str	r3, [r0]                                      
    25e0:	ea00006f 	b	27a4 <mount+0x2f0>                              
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( has_target ) {                                                 
    if ( rtems_filesystem_evaluate_path(                              
    25e4:	e28d6014 	add	r6, sp, #20                                   
    25e8:	e3a0c001 	mov	ip, #1                                        
    25ec:	e1a00007 	mov	r0, r7                                        
    25f0:	e59d1008 	ldr	r1, [sp, #8]                                  
    25f4:	e3a02007 	mov	r2, #7                                        
    25f8:	e1a03006 	mov	r3, r6                                        
    25fc:	e58dc000 	str	ip, [sp]                                      
    2600:	ebfffe14 	bl	1e58 <rtems_filesystem_evaluate_path>          
    2604:	e3700001 	cmn	r0, #1                                        
    2608:	0a000058 	beq	2770 <mount+0x2bc>                            
                                                                      
    /*                                                                
     * Test for node_type_h                                           
     */                                                               
                                                                      
    if (!loc.ops->node_type_h) {                                      
    260c:	e59d3020 	ldr	r3, [sp, #32]                                 
    2610:	e5933010 	ldr	r3, [r3, #16]                                 
    2614:	e3530000 	cmp	r3, #0                                        
    2618:	0a00001b 	beq	268c <mount+0x1d8>                            
                                                                      
    /*                                                                
     *  Test to see if it is a directory                              
     */                                                               
                                                                      
    if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
    261c:	e1a00006 	mov	r0, r6                                        
    2620:	e1a0e00f 	mov	lr, pc                                        
    2624:	e12fff13 	bx	r3                                             
    2628:	e3500001 	cmp	r0, #1                                        
    262c:	0a000003 	beq	2640 <mount+0x18c>                            
      errno = ENOTDIR;                                                
    2630:	eb002b63 	bl	d3c4 <__errno>                                 
    2634:	e3a03014 	mov	r3, #20                                       
    2638:	e5803000 	str	r3, [r0]                                      
      goto cleanup_and_bail;                                          
    263c:	ea00004c 	b	2774 <mount+0x2c0>                              
                                                                      
    /*                                                                
     *  You can only mount one file system onto a single mount point. 
     */                                                               
                                                                      
    if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
    2640:	e59f0170 	ldr	r0, [pc, #368]	; 27b8 <mount+0x304>           
    2644:	e59d1014 	ldr	r1, [sp, #20]                                 
    2648:	ebffff7c 	bl	2440 <rtems_filesystem_mount_iterate>          
    264c:	e3500000 	cmp	r0, #0                                        
    2650:	0a000002 	beq	2660 <mount+0x1ac>                            
      errno = EBUSY;                                                  
    2654:	eb002b5a 	bl	d3c4 <__errno>                                 
    2658:	e3a03010 	mov	r3, #16                                       
    265c:	eafffff5 	b	2638 <mount+0x184>                              
     *  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;            
    2660:	e59d1014 	ldr	r1, [sp, #20]                                 
    mt_entry->mt_point_node.handlers = loc.handlers;                  
    mt_entry->mt_point_node.ops = loc.ops;                            
    2664:	e59d2020 	ldr	r2, [sp, #32]                                 
     *  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;            
    2668:	e5841008 	str	r1, [r4, #8]                                  
    mt_entry->mt_point_node.handlers = loc.handlers;                  
    266c:	e59d101c 	ldr	r1, [sp, #28]                                 
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( !loc.ops->mount_h ){                                         
    2670:	e5923020 	ldr	r3, [r2, #32]                                 
     *  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;                  
    2674:	e5841010 	str	r1, [r4, #16]                                 
    mt_entry->mt_point_node.ops = loc.ops;                            
    mt_entry->mt_point_node.mt_entry = loc.mt_entry;                  
    2678:	e59d1024 	ldr	r1, [sp, #36]	; 0x24                          
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( !loc.ops->mount_h ){                                         
    267c:	e3530000 	cmp	r3, #0                                        
     */                                                               
                                                                      
    mt_entry->mt_point_node.node_access = loc.node_access;            
    mt_entry->mt_point_node.handlers = loc.handlers;                  
    mt_entry->mt_point_node.ops = loc.ops;                            
    mt_entry->mt_point_node.mt_entry = loc.mt_entry;                  
    2680:	e5841018 	str	r1, [r4, #24]                                 
     *  traverse the tree.                                            
     */                                                               
                                                                      
    mt_entry->mt_point_node.node_access = loc.node_access;            
    mt_entry->mt_point_node.handlers = loc.handlers;                  
    mt_entry->mt_point_node.ops = loc.ops;                            
    2684:	e5842014 	str	r2, [r4, #20]                                 
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( !loc.ops->mount_h ){                                         
    2688:	1a000002 	bne	2698 <mount+0x1e4>                            
      errno = ENOTSUP;                                                
    268c:	eb002b4c 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    2690:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    2694:	eaffffe7 	b	2638 <mount+0x184>                              <== NOT EXECUTED
      goto cleanup_and_bail;                                          
    }                                                                 
                                                                      
    if ( loc.ops->mount_h( mt_entry ) ) {                             
    2698:	e1a00004 	mov	r0, r4                                        
    269c:	e1a0e00f 	mov	lr, pc                                        
    26a0:	e12fff13 	bx	r3                                             
    26a4:	e3500000 	cmp	r0, #0                                        
    26a8:	0a00000b 	beq	26dc <mount+0x228>                            
    26ac:	ea000030 	b	2774 <mount+0x2c0>                              <== NOT EXECUTED
    }                                                                 
  } else {                                                            
    /*                                                                
     * Do we already have a base file system ?                        
     */                                                               
    if ( !rtems_chain_is_empty( &mount_chain ) ) {                    
    26b0:	e59f3104 	ldr	r3, [pc, #260]	; 27bc <mount+0x308>           
    26b4:	e5932000 	ldr	r2, [r3]                                      
    26b8:	e2833004 	add	r3, r3, #4                                    
    26bc:	e1520003 	cmp	r2, r3                                        
    26c0:	01a06005 	moveq	r6, r5                                      
    26c4:	0a000004 	beq	26dc <mount+0x228>                            
      errno = EINVAL;                                                 
    26c8:	eb002b3d 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    26cc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    26d0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    26d4:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
      goto cleanup_and_bail;                                          
    26d8:	ea000025 	b	2774 <mount+0x2c0>                              <== NOT EXECUTED
     *  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 ) ) {                               
    26dc:	e59d104c 	ldr	r1, [sp, #76]	; 0x4c                          
    26e0:	e1a00004 	mov	r0, r4                                        
    26e4:	e59d3010 	ldr	r3, [sp, #16]                                 
    26e8:	e1a0e00f 	mov	lr, pc                                        
    26ec:	e12fff13 	bx	r3                                             
    26f0:	e2507000 	subs	r7, r0, #0                                   
    26f4:	0a000007 	beq	2718 <mount+0x264>                            
    /*                                                                
     * Try to undo the mount operation                                
     */                                                               
    if ( loc.ops->unmount_h ) {                                       
    26f8:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
    26fc:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          <== NOT EXECUTED
    2700:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    2704:	0a00001a 	beq	2774 <mount+0x2c0>                            <== NOT EXECUTED
      loc.ops->unmount_h( mt_entry );                                 
    2708:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    270c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    2710:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    2714:	ea000016 	b	2774 <mount+0x2c0>                              <== 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 );
    2718:	e59f60a0 	ldr	r6, [pc, #160]	; 27c0 <mount+0x30c>           
    271c:	e1a02007 	mov	r2, r7                                        
    2720:	e1a01007 	mov	r1, r7                                        
    2724:	e5960000 	ldr	r0, [r6]                                      
    2728:	eb000a9b 	bl	519c <rtems_semaphore_obtain>                  
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
    272c:	e1a01004 	mov	r1, r4                                        
    2730:	e59f0084 	ldr	r0, [pc, #132]	; 27bc <mount+0x308>           
    2734:	eb000cc3 	bl	5a48 <_Chain_Append>                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
    2738:	e5960000 	ldr	r0, [r6]                                      
    273c:	eb000adc 	bl	52b4 <rtems_semaphore_release>                 
   */                                                                 
  rtems_libio_lock();                                                 
  rtems_chain_append( &mount_chain, &mt_entry->Node );                
  rtems_libio_unlock();                                               
                                                                      
  if ( !has_target )                                                  
    2740:	e3550000 	cmp	r5, #0                                        
    rtems_filesystem_root = mt_entry->mt_fs_root;                     
    2744:	059f3078 	ldreq	r3, [pc, #120]	; 27c4 <mount+0x310>         
    2748:	0284401c 	addeq	r4, r4, #28                                 
    274c:	0593c000 	ldreq	ip, [r3]                                    
    2750:	08b4000f 	ldmeq	r4!, {r0, r1, r2, r3}                       
    2754:	028cc018 	addeq	ip, ip, #24                                 
    2758:	08ac000f 	stmiaeq	ip!, {r0, r1, r2, r3}                     
    275c:	05943000 	ldreq	r3, [r4]                                    
   */                                                                 
  rtems_libio_lock();                                                 
  rtems_chain_append( &mount_chain, &mt_entry->Node );                
  rtems_libio_unlock();                                               
                                                                      
  if ( !has_target )                                                  
    2760:	11a00007 	movne	r0, r7                                      
    rtems_filesystem_root = mt_entry->mt_fs_root;                     
    2764:	058c3000 	streq	r3, [ip]                                    
    2768:	01a00005 	moveq	r0, r5                                      
    276c:	ea00000d 	b	27a8 <mount+0x2f4>                              
    2770:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
                                                                      
cleanup_and_bail:                                                     
                                                                      
  free( mt_entry );                                                   
    2774:	e1a00004 	mov	r0, r4                                        
    2778:	ebfffdd4 	bl	1ed0 <free>                                    
                                                                      
  if ( loc_to_free )                                                  
    277c:	e3560000 	cmp	r6, #0                                        
    2780:	0a000007 	beq	27a4 <mount+0x2f0>                            
    rtems_filesystem_freenode( loc_to_free );                         
    2784:	e596300c 	ldr	r3, [r6, #12]                                 
    2788:	e3530000 	cmp	r3, #0                                        
    278c:	0a000004 	beq	27a4 <mount+0x2f0>                            
    2790:	e593301c 	ldr	r3, [r3, #28]                                 
    2794:	e3530000 	cmp	r3, #0                                        
    2798:	11a00006 	movne	r0, r6                                      
    279c:	11a0e00f 	movne	lr, pc                                      
    27a0:	112fff13 	bxne	r3                                           
    27a4:	e3e00000 	mvn	r0, #0                                        
                                                                      
  return -1;                                                          
}                                                                     
    27a8:	e28dd028 	add	sp, sp, #40	; 0x28                            
    27ac:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
                                                                      

00030f04 <msdos_creat_node>: msdos_node_type_t type, const char *name, int name_len, mode_t mode, const fat_file_fd_t *link_fd) {
   30f04:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   30f08:	e24dd0a8 	sub	sp, sp, #168	; 0xa8                           <== NOT EXECUTED
    int               rc = RC_OK;                                     
    ssize_t           ret = 0;                                        
    msdos_fs_info_t  *fs_info = parent_loc->mt_entry->fs_info;        
    fat_file_fd_t    *parent_fat_fd = parent_loc->node_access;        
    fat_file_fd_t    *fat_fd = NULL;                                  
   30f0c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
                 mode_t                             mode,             
                 const fat_file_fd_t               *link_fd)          
{                                                                     
    int               rc = RC_OK;                                     
    ssize_t           ret = 0;                                        
    msdos_fs_info_t  *fs_info = parent_loc->mt_entry->fs_info;        
   30f10:	e590e010 	ldr	lr, [r0, #16]                                 <== NOT EXECUTED
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   30f14:	e28da070 	add	sl, sp, #112	; 0x70                           <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   30f18:	e3e0c000 	mvn	ip, #0                                        <== NOT EXECUTED
                 msdos_node_type_t                  type,             
                 const char                        *name,             
                 int                                name_len,         
                 mode_t                             mode,             
                 const fat_file_fd_t               *link_fd)          
{                                                                     
   30f1c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   30f20:	e1a09002 	mov	r9, r2                                        <== NOT EXECUTED
   30f24:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   30f28:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   30f2c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   30f30:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
   30f34:	e58dc09c 	str	ip, [sp, #156]	; 0x9c                         <== NOT EXECUTED
                 msdos_node_type_t                  type,             
                 const char                        *name,             
                 int                                name_len,         
                 mode_t                             mode,             
                 const fat_file_fd_t               *link_fd)          
{                                                                     
   30f38:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
    int               rc = RC_OK;                                     
    ssize_t           ret = 0;                                        
    msdos_fs_info_t  *fs_info = parent_loc->mt_entry->fs_info;        
   30f3c:	e59e8034 	ldr	r8, [lr, #52]	; 0x34                          <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   30f40:	e58dc098 	str	ip, [sp, #152]	; 0x98                         <== NOT EXECUTED
    fat_file_fd_t    *parent_fat_fd = parent_loc->node_access;        
    fat_file_fd_t    *fat_fd = NULL;                                  
   30f44:	e58d50a0 	str	r5, [sp, #160]	; 0xa0                         <== NOT EXECUTED
    time_t            time_ret = 0;                                   
    uint16_t          time_val = 0;                                   
   30f48:	e1cd5ab6 	strh	r5, [sp, #166]	; 0xa6                        <== NOT EXECUTED
    uint16_t          date = 0;                                       
   30f4c:	e1cd5ab4 	strh	r5, [sp, #164]	; 0xa4                        <== NOT EXECUTED
static inline void                                                    
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
   30f50:	e58d5090 	str	r5, [sp, #144]	; 0x90                         <== NOT EXECUTED
  dir_pos->sname.ofs = 0;                                             
   30f54:	e58d5094 	str	r5, [sp, #148]	; 0x94                         <== NOT EXECUTED
                 const fat_file_fd_t               *link_fd)          
{                                                                     
    int               rc = RC_OK;                                     
    ssize_t           ret = 0;                                        
    msdos_fs_info_t  *fs_info = parent_loc->mt_entry->fs_info;        
    fat_file_fd_t    *parent_fat_fd = parent_loc->node_access;        
   30f58:	e5947000 	ldr	r7, [r4]                                      <== NOT EXECUTED
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   30f5c:	eb003d1e 	bl	403dc <memset>                                 <== NOT EXECUTED
    memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);     
   30f60:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   30f64:	e3a02040 	mov	r2, #64	; 0x40                                <== NOT EXECUTED
   30f68:	e28d0010 	add	r0, sp, #16                                   <== NOT EXECUTED
   30f6c:	eb003d1a 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    name_type = msdos_long_to_short (name, name_len,                  
   30f70:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   30f74:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   30f78:	e3a0300b 	mov	r3, #11                                       <== NOT EXECUTED
   30f7c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   30f80:	eb000786 	bl	32da0 <msdos_long_to_short>                    <== NOT EXECUTED
   30f84:	e58d000c 	str	r0, [sp, #12]                                 <== NOT EXECUTED
                                                                      
    /* fill reserved field */                                         
    *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;               
                                                                      
    /* set up last write date and time */                             
    time_ret = time(NULL);                                            
   30f88:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    name_type = msdos_long_to_short (name, name_len,                  
                                     MSDOS_DIR_NAME(short_node),      
                                     MSDOS_NAME_MAX);                 
                                                                      
    /* fill reserved field */                                         
    *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;               
   30f8c:	e5cd507c 	strb	r5, [sp, #124]	; 0x7c                        <== NOT EXECUTED
                                                                      
    /* set up last write date and time */                             
    time_ret = time(NULL);                                            
   30f90:	eb005f4c 	bl	48cc8 <time>                                   <== NOT EXECUTED
    if ( time_ret == -1 )                                             
   30f94:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
   30f98:	0a0000a9 	beq	31244 <msdos_creat_node+0x340>                <== NOT EXECUTED
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
   30f9c:	e28d10a4 	add	r1, sp, #164	; 0xa4                           <== NOT EXECUTED
   30fa0:	e28d20a6 	add	r2, sp, #166	; 0xa6                           <== NOT EXECUTED
   30fa4:	eb0029cf 	bl	3b6e8 <msdos_date_unix2dos>                    <== NOT EXECUTED
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
   30fa8:	e1dd3ab6 	ldrh	r3, [sp, #166]	; 0xa6                        <== NOT EXECUTED
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
   30fac:	e3560001 	cmp	r6, #1                                        <== NOT EXECUTED
    time_ret = time(NULL);                                            
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
   30fb0:	e1cd38b6 	strh	r3, [sp, #134]	; 0x86                        <== NOT EXECUTED
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
   30fb4:	e1ddcab4 	ldrh	ip, [sp, #164]	; 0xa4                        <== NOT EXECUTED
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
   30fb8:	05dd307b 	ldrbeq	r3, [sp, #123]	; 0x7b                      <== NOT EXECUTED
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
   30fbc:	e58d508c 	str	r5, [sp, #140]	; 0x8c                         <== NOT EXECUTED
    if ( time_ret == -1 )                                             
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
   30fc0:	e1cdc8b8 	strh	ip, [sp, #136]	; 0x88                        <== NOT EXECUTED
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
   30fc4:	03833010 	orreq	r3, r3, #16                                 <== NOT EXECUTED
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
   30fc8:	0a000032 	beq	31098 <msdos_creat_node+0x194>                <== NOT EXECUTED
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
    }                                                                 
    else if (type == MSDOS_HARD_LINK) {                               
   30fcc:	e3560003 	cmp	r6, #3                                        <== NOT EXECUTED
       * set "last access" date to today                              
       */                                                             
      *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);        
    }                                                                 
    else { /* regular file... */                                      
        *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;            
   30fd0:	15dd307b 	ldrbne	r3, [sp, #123]	; 0x7b                      <== NOT EXECUTED
   30fd4:	13833020 	orrne	r3, r3, #32                                 <== NOT EXECUTED
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
    }                                                                 
    else if (type == MSDOS_HARD_LINK) {                               
   30fd8:	1a00002e 	bne	31098 <msdos_creat_node+0x194>                <== NOT EXECUTED
       * node to the newly created                                    
       */                                                             
      /*                                                              
       * read the original directory entry                            
       */                                                             
      sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,       
   30fdc:	e59d30d0 	ldr	r3, [sp, #208]	; 0xd0                         <== NOT EXECUTED
   30fe0:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
   30fe4:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   30fe8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   30fec:	e5903034 	ldr	r3, [r0, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   30ff0:	1a000003 	bne	31004 <msdos_creat_node+0x100>                <== NOT EXECUTED
   30ff4:	e5d3100a 	ldrb	r1, [r3, #10]                                <== NOT EXECUTED
   30ff8:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   30ffc:	1593101c 	ldrne	r1, [r3, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   31000:	1a000003 	bne	31014 <msdos_creat_node+0x110>                <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   31004:	e593c030 	ldr	ip, [r3, #48]	; 0x30                          <== NOT EXECUTED
   31008:	e5d33005 	ldrb	r3, [r3, #5]                                 <== NOT EXECUTED
   3100c:	e2421002 	sub	r1, r2, #2                                    <== NOT EXECUTED
   31010:	e08c1311 	add	r1, ip, r1, lsl r3                            <== NOT EXECUTED
                                          link_fd->dir_pos.sname.cln);
      sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
   31014:	e59dc0d0 	ldr	ip, [sp, #208]	; 0xd0                         <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
                                                                      
      ret = _fat_block_read(parent_loc->mt_entry,                     
   31018:	e1d820b0 	ldrh	r2, [r8]                                     <== NOT EXECUTED
      /*                                                              
       * read the original directory entry                            
       */                                                             
      sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,       
                                          link_fd->dir_pos.sname.cln);
      sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
   3101c:	e59c3024 	ldr	r3, [ip, #36]	; 0x24                          <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
                                                                      
      ret = _fat_block_read(parent_loc->mt_entry,                     
   31020:	e5d8c002 	ldrb	ip, [r8, #2]                                 <== NOT EXECUTED
   31024:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   31028:	e0811c33 	add	r1, r1, r3, lsr ip                            <== NOT EXECUTED
   3102c:	e0022003 	and	r2, r2, r3                                    <== NOT EXECUTED
   31030:	e28dc050 	add	ip, sp, #80	; 0x50                            <== NOT EXECUTED
   31034:	e3a03020 	mov	r3, #32                                       <== NOT EXECUTED
   31038:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   3103c:	ebffc719 	bl	22ca8 <_fat_block_read>                        <== NOT EXECUTED
                            sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
                            link_node);                               
      if (ret < 0) {                                                  
   31040:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31044:	ba00007e 	blt	31244 <msdos_creat_node+0x340>                <== NOT EXECUTED
          return -1;                                                  
      }                                                               
      /*                                                              
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
   31048:	e5dd305b 	ldrb	r3, [sp, #91]	; 0x5b                         <== NOT EXECUTED
   3104c:	e5cd307b 	strb	r3, [sp, #123]	; 0x7b                        <== NOT EXECUTED
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
           *MSDOS_DIR_FIRST_CLUSTER_HI(link_node);                    
      /*                                                              
       * set "archive bit" due to changes                             
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
   31050:	e5dd307b 	ldrb	r3, [sp, #123]	; 0x7b                        <== NOT EXECUTED
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
                                                                      
      /*                                                              
       * copy/set "file size", "first cluster"                        
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
   31054:	e59d106c 	ldr	r1, [sp, #108]	; 0x6c                         <== NOT EXECUTED
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
           *MSDOS_DIR_FIRST_CLUSTER_HI(link_node);                    
      /*                                                              
       * set "archive bit" due to changes                             
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
   31058:	e3833020 	orr	r3, r3, #32                                   <== NOT EXECUTED
      }                                                               
      /*                                                              
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
   3105c:	e5dd205d 	ldrb	r2, [sp, #93]	; 0x5d                         <== NOT EXECUTED
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
                                                                      
      /*                                                              
       * copy/set "file size", "first cluster"                        
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
   31060:	e58a101c 	str	r1, [sl, #28]                                 <== NOT EXECUTED
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
           *MSDOS_DIR_FIRST_CLUSTER_HI(link_node);                    
      /*                                                              
       * set "archive bit" due to changes                             
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
   31064:	e5cd307b 	strb	r3, [sp, #123]	; 0x7b                        <== NOT EXECUTED
      /*                                                              
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
      *MSDOS_DIR_CRT_TIME(short_node)      =*MSDOS_DIR_CRT_TIME(link_node);
   31068:	e1dd35be 	ldrh	r3, [sp, #94]	; 0x5e                         <== NOT EXECUTED
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
   3106c:	e1ddc6b0 	ldrh	ip, [sp, #96]	; 0x60                         <== NOT EXECUTED
      /*                                                              
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
      *MSDOS_DIR_CRT_TIME(short_node)      =*MSDOS_DIR_CRT_TIME(link_node);
   31070:	e1cd37be 	strh	r3, [sp, #126]	; 0x7e                        <== NOT EXECUTED
      /*                                                              
       * copy/set "file size", "first cluster"                        
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
                                                                      
      *MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =                      
   31074:	e1dd36ba 	ldrh	r3, [sp, #106]	; 0x6a                        <== NOT EXECUTED
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
      *MSDOS_DIR_CRT_TIME(short_node)      =*MSDOS_DIR_CRT_TIME(link_node);
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
   31078:	e1cdc8b0 	strh	ip, [sp, #128]	; 0x80                        <== NOT EXECUTED
      /*                                                              
       * copy/set "file size", "first cluster"                        
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
                                                                      
      *MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =                      
   3107c:	e1cd38ba 	strh	r3, [sp, #138]	; 0x8a                        <== NOT EXECUTED
           *MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);                   
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
   31080:	e1ddc6b4 	ldrh	ip, [sp, #100]	; 0x64                        <== NOT EXECUTED
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
      /*                                                              
       * set "last access" date to today                              
       */                                                             
      *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);        
   31084:	e1dd3ab4 	ldrh	r3, [sp, #164]	; 0xa4                        <== NOT EXECUTED
      }                                                               
      /*                                                              
       * copy various attributes                                      
       */                                                             
      *MSDOS_DIR_ATTR(short_node)          =*MSDOS_DIR_ATTR(link_node);
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
   31088:	e5cd207d 	strb	r2, [sp, #125]	; 0x7d                        <== NOT EXECUTED
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
                                                                      
      *MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =                      
           *MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);                   
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
   3108c:	e1cdc8b4 	strh	ip, [sp, #132]	; 0x84                        <== NOT EXECUTED
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
      /*                                                              
       * set "last access" date to today                              
       */                                                             
      *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);        
   31090:	e1cd38b2 	strh	r3, [sp, #130]	; 0x82                        <== NOT EXECUTED
   31094:	ea000000 	b	3109c <msdos_creat_node+0x198>                  <== NOT EXECUTED
    }                                                                 
    else { /* regular file... */                                      
        *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;            
   31098:	e5cd307b 	strb	r3, [sp, #123]	; 0x7b                        <== NOT EXECUTED
                                                                      
    /*                                                                
     * find free space in the parent directory and write new initialized
     * FAT 32 Bytes Directory Entry Structure to the disk             
     */                                                               
    rc = msdos_get_name_node(parent_loc, true, name, name_len,        
   3109c:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
   310a0:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   310a4:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
   310a8:	e28d9090 	add	r9, sp, #144	; 0x90                           <== NOT EXECUTED
   310ac:	e28da070 	add	sl, sp, #112	; 0x70                           <== NOT EXECUTED
   310b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   310b4:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   310b8:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   310bc:	e98d0600 	stmib	sp, {r9, sl}                                <== NOT EXECUTED
   310c0:	eb000820 	bl	33148 <msdos_get_name_node>                    <== NOT EXECUTED
                             name_type, &dir_pos, short_node);        
    if ( rc != RC_OK )                                                
   310c4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   310c8:	1a00005e 	bne	31248 <msdos_creat_node+0x344>                <== NOT EXECUTED
                                                                      
    /*                                                                
     * if we create a new file we are done, if directory there are more steps
     * to do                                                          
     */                                                               
    if (type == MSDOS_DIRECTORY)                                      
   310cc:	e3560001 	cmp	r6, #1                                        <== NOT EXECUTED
   310d0:	1a00005c 	bne	31248 <msdos_creat_node+0x344>                <== NOT EXECUTED
    {                                                                 
        /* open new directory as fat-file */                          
        rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);  
   310d4:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   310d8:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   310dc:	e28d20a0 	add	r2, sp, #160	; 0xa0                           <== NOT EXECUTED
   310e0:	ebffc49d 	bl	2235c <fat_file_open>                          <== NOT EXECUTED
        if (rc != RC_OK)                                              
   310e4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   310e8:	1a000050 	bne	31230 <msdos_creat_node+0x32c>                <== NOT EXECUTED
                                                                      
        /*                                                            
         * we opened fat-file for node we just created, so initialize fat-file
         * descritor                                                  
         */                                                           
        fat_fd->fat_file_size = 0;                                    
   310ec:	e59d30a0 	ldr	r3, [sp, #160]	; 0xa0                         <== NOT EXECUTED
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
   310f0:	e3a02602 	mov	r2, #2097152	; 0x200000                       <== NOT EXECUTED
                                                                      
        /*                                                            
         * we opened fat-file for node we just created, so initialize fat-file
         * descritor                                                  
         */                                                           
        fat_fd->fat_file_size = 0;                                    
   310f4:	e5835018 	str	r5, [r3, #24]                                 <== NOT EXECUTED
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
   310f8:	e5836010 	str	r6, [r3, #16]                                 <== NOT EXECUTED
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
   310fc:	e5832014 	str	r2, [r3, #20]                                 <== NOT EXECUTED
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
   31100:	e1a0e00a 	mov	lr, sl                                        <== NOT EXECUTED
   31104:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   31108:	e28d5010 	add	r5, sp, #16                                   <== NOT EXECUTED
   3110c:	e1a0c005 	mov	ip, r5                                        <== NOT EXECUTED
   31110:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   31114:	e89e000f 	ldm	lr, {r0, r1, r2, r3}                          <== NOT EXECUTED
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
   31118:	e2856020 	add	r6, r5, #32                                   <== NOT EXECUTED
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
   3111c:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          <== NOT EXECUTED
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
   31120:	e8ba000f 	ldm	sl!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   31124:	e1a0c006 	mov	ip, r6                                        <== NOT EXECUTED
   31128:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   3112c:	e89e000f 	ldm	lr, {r0, r1, r2, r3}                          <== NOT EXECUTED
   31130:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          <== NOT EXECUTED
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
   31134:	e59f3118 	ldr	r3, [pc, #280]	; 31254 <msdos_creat_node+0x350><== NOT EXECUTED
   31138:	e3a0200b 	mov	r2, #11                                       <== NOT EXECUTED
   3113c:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
   31140:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   31144:	eb003c1d 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
               MSDOS_NAME_MAX);                                       
        memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
   31148:	e59f3108 	ldr	r3, [pc, #264]	; 31258 <msdos_creat_node+0x354><== NOT EXECUTED
   3114c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   31150:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
   31154:	e3a0200b 	mov	r2, #11                                       <== NOT EXECUTED
   31158:	eb003c18 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
        /*                                                            
         * here we can ommit FAT32 condition because for all FAT types dirs
         * right under root dir should contain 0 in dotdot entry but for
         * FAT12/16 parent_fat_fd->cluster_num always contains such value
         */                                                           
        if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&                    
   3115c:	e5973020 	ldr	r3, [r7, #32]                                 <== NOT EXECUTED
   31160:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   31164:	1a000007 	bne	31188 <msdos_creat_node+0x284>                <== NOT EXECUTED
   31168:	e5973024 	ldr	r3, [r7, #36]	; 0x24                          <== NOT EXECUTED
   3116c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   31170:	1a000004 	bne	31188 <msdos_creat_node+0x284>                <== NOT EXECUTED
            (fs_info->fat.vol.type & FAT_FAT32))                      
   31174:	e5d8200a 	ldrb	r2, [r8, #10]                                <== NOT EXECUTED
   31178:	e3120004 	tst	r2, #4                                        <== NOT EXECUTED
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
   3117c:	11c533b4 	strhne	r3, [r5, #52]	; 0x34                       <== NOT EXECUTED
         * FAT12/16 parent_fat_fd->cluster_num always contains such value
         */                                                           
        if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&                    
            (fs_info->fat.vol.type & FAT_FAT32))                      
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
   31180:	11c533ba 	strhne	r3, [r5, #58]	; 0x3a                       <== NOT EXECUTED
         * here we can ommit FAT32 condition because for all FAT types dirs
         * right under root dir should contain 0 in dotdot entry but for
         * FAT12/16 parent_fat_fd->cluster_num always contains such value
         */                                                           
        if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&                    
            (fs_info->fat.vol.type & FAT_FAT32))                      
   31184:	1a000003 	bne	31198 <msdos_creat_node+0x294>                <== NOT EXECUTED
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
        }                                                             
        else                                                          
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 
   31188:	e597301c 	ldr	r3, [r7, #28]                                 <== NOT EXECUTED
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =  
   3118c:	e1a02823 	lsr	r2, r3, #16                                   <== NOT EXECUTED
   31190:	e1cd24b4 	strh	r2, [sp, #68]	; 0x44                         <== NOT EXECUTED
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
        }                                                             
        else                                                          
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 
   31194:	e1cd34ba 	strh	r3, [sp, #74]	; 0x4a                         <== NOT EXECUTED
        /*                                                            
         * write dot and dotdot entries to new fat-file: currently fat-file
         * correspondes to a new node is zero length, so it will be extended
         * by one cluster and entries will be written                 
         */                                                           
        ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,         
   31198:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   3119c:	e28d5010 	add	r5, sp, #16                                   <== NOT EXECUTED
   311a0:	e59d10a0 	ldr	r1, [sp, #160]	; 0xa0                         <== NOT EXECUTED
   311a4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   311a8:	e3a03040 	mov	r3, #64	; 0x40                                <== NOT EXECUTED
   311ac:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
   311b0:	ebffc339 	bl	21e9c <fat_file_write>                         <== NOT EXECUTED
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,   
                             (uint8_t *)dot_dotdot);                  
        if (ret < 0)                                                  
   311b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   311b8:	ba000018 	blt	31220 <msdos_creat_node+0x31c>                <== NOT EXECUTED
            rc = -1;                                                  
            goto error;                                               
        }                                                             
                                                                      
        /* increment fat-file size by cluster size */                 
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
   311bc:	e59d10a0 	ldr	r1, [sp, #160]	; 0xa0                         <== NOT EXECUTED
   311c0:	e1d830b6 	ldrh	r3, [r8, #6]                                 <== NOT EXECUTED
   311c4:	e2812018 	add	r2, r1, #24                                   <== NOT EXECUTED
   311c8:	e8921004 	ldm	r2, {r2, ip}                                  <== NOT EXECUTED
   311cc:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
   311d0:	e5813018 	str	r3, [r1, #24]                                 <== NOT EXECUTED
                                                                      
        /* set up cluster num for dot entry */                        
        *MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
   311d4:	e1a0e82c 	lsr	lr, ip, #16                                   <== NOT EXECUTED
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
                                                                      
        /* rewrite dot entry */                                       
        ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,         
   311d8:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   311dc:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   311e0:	e3a03020 	mov	r3, #32                                       <== NOT EXECUTED
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
                                                                      
        /* set up cluster num for dot entry */                        
        *MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
   311e4:	e1cde2b4 	strh	lr, [sp, #36]	; 0x24                         <== NOT EXECUTED
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
                                                                      
        /* rewrite dot entry */                                       
        ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,         
   311e8:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
                                                                      
        /* increment fat-file size by cluster size */                 
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
                                                                      
        /* set up cluster num for dot entry */                        
        *MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =        
   311ec:	e1cdc2ba 	strh	ip, [sp, #42]	; 0x2a                         <== NOT EXECUTED
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
                                                                      
        /* rewrite dot entry */                                       
        ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,         
   311f0:	ebffc329 	bl	21e9c <fat_file_write>                         <== NOT EXECUTED
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,       
                             (uint8_t *)DOT_NODE_P(dot_dotdot));      
        if (ret < 0)                                                  
   311f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   311f8:	ba000008 	blt	31220 <msdos_creat_node+0x31c>                <== NOT EXECUTED
            rc = -1;                                                  
            goto error;                                               
        }                                                             
                                                                      
        /* write first cluster num of a new directory to disk */      
        rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
   311fc:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31200:	e59d10a0 	ldr	r1, [sp, #160]	; 0xa0                         <== NOT EXECUTED
   31204:	eb0005e9 	bl	329b0 <msdos_set_first_cluster_num>            <== NOT EXECUTED
        if (rc != RC_OK)                                              
   31208:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   3120c:	1a000004 	bne	31224 <msdos_creat_node+0x320>                <== NOT EXECUTED
            goto error;                                               
                                                                      
        fat_file_close(parent_loc->mt_entry, fat_fd);                 
   31210:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31214:	e59d10a0 	ldr	r1, [sp, #160]	; 0xa0                         <== NOT EXECUTED
   31218:	ebffc426 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   3121c:	ea000009 	b	31248 <msdos_creat_node+0x344>                  <== NOT EXECUTED
   31220:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
    }                                                                 
    return RC_OK;                                                     
                                                                      
error:                                                                
    fat_file_close(parent_loc->mt_entry, fat_fd);                     
   31224:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31228:	e59d10a0 	ldr	r1, [sp, #160]	; 0xa0                         <== NOT EXECUTED
   3122c:	ebffc421 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
                                                                      
err:                                                                  
    /* mark the used 32bytes structure on the disk as free */         
    msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
   31230:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31234:	e28d1090 	add	r1, sp, #144	; 0x90                           <== NOT EXECUTED
   31238:	e3a020e5 	mov	r2, #229	; 0xe5                               <== NOT EXECUTED
   3123c:	eb000608 	bl	32a64 <msdos_set_first_char4file_name>         <== NOT EXECUTED
    return rc;                                                        
   31240:	ea000000 	b	31248 <msdos_creat_node+0x344>                  <== NOT EXECUTED
   31244:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
}                                                                     
   31248:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3124c:	e28dd0a8 	add	sp, sp, #168	; 0xa8                           <== NOT EXECUTED
   31250:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0003b830 <msdos_date_dos2unix>: + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600; /* * If the year, month, and day from the last conversion are the * same then use the saved value. */ if (lastdosdate != dd) {
   3b830:	e59f30e4 	ldr	r3, [pc, #228]	; 3b91c <msdos_date_dos2unix+0xec><== NOT EXECUTED
   3b834:	e1d320be 	ldrh	r2, [r3, #14]                                <== NOT EXECUTED
   3b838:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
 * called from the stat(), and fstat() system calls and so probably need
 * not be too efficient.                                              
 */                                                                   
unsigned int                                                          
msdos_date_dos2unix(unsigned int dd, unsigned int dt)                 
{                                                                     
   3b83c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
	/*                                                                   
	 * If the year, month, and day from the last conversion are the      
	 * same then use the saved value.                                    
	 */                                                                  
	if (lastdosdate != dd) {                                             
   3b840:	0a000028 	beq	3b8e8 <msdos_date_dos2unix+0xb8>              <== NOT EXECUTED
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
   3b844:	e200ccfe 	and	ip, r0, #65024	; 0xfe00                       <== NOT EXECUTED
   3b848:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
	/*                                                                   
	 * If the year, month, and day from the last conversion are the      
	 * same then use the saved value.                                    
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
   3b84c:	e1c300be 	strh	r0, [r3, #14]                                <== NOT EXECUTED
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
   3b850:	e1a0c4ac 	lsr	ip, ip, #9                                    <== NOT EXECUTED
   3b854:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
		for (y = 0; y < year; y++)                                          
			days += y & 0x03 ? 365 : 366;                                      
   3b858:	e59f50c0 	ldr	r5, [pc, #192]	; 3b920 <msdos_date_dos2unix+0xf0><== NOT EXECUTED
   3b85c:	e59f40c0 	ldr	r4, [pc, #192]	; 3b924 <msdos_date_dos2unix+0xf4><== NOT EXECUTED
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
   3b860:	ea000004 	b	3b878 <msdos_date_dos2unix+0x48>                <== NOT EXECUTED
			days += y & 0x03 ? 365 : 366;                                      
   3b864:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
   3b868:	11a06005 	movne	r6, r5                                      <== NOT EXECUTED
   3b86c:	01a06004 	moveq	r6, r4                                      <== NOT EXECUTED
   3b870:	e0833006 	add	r3, r3, r6                                    <== NOT EXECUTED
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
   3b874:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   3b878:	e152000c 	cmp	r2, ip                                        <== NOT EXECUTED
   3b87c:	3afffff8 	bcc	3b864 <msdos_date_dos2unix+0x34>              <== NOT EXECUTED
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
   3b880:	e31c0003 	tst	ip, #3                                        <== NOT EXECUTED
   3b884:	e59f409c 	ldr	r4, [pc, #156]	; 3b928 <msdos_date_dos2unix+0xf8><== NOT EXECUTED
   3b888:	e59fc09c 	ldr	ip, [pc, #156]	; 3b92c <msdos_date_dos2unix+0xfc><== NOT EXECUTED
		/*                                                                  
		 * Prevent going from 0 to 0xffffffff in the following              
		 * loop.                                                            
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
   3b88c:	e2002e1e 	and	r2, r0, #480	; 0x1e0                          <== NOT EXECUTED
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
   3b890:	01a0400c 	moveq	r4, ip                                      <== NOT EXECUTED
		/*                                                                  
		 * Prevent going from 0 to 0xffffffff in the following              
		 * loop.                                                            
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
   3b894:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   3b898:	11a022a2 	lsrne	r2, r2, #5                                  <== NOT EXECUTED
   3b89c:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
   3b8a0:	e242c001 	sub	ip, r2, #1                                    <== NOT EXECUTED
		/*                                                                  
		 * Prevent going from 0 to 0xffffffff in the following              
		 * loop.                                                            
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
   3b8a4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
   3b8a8:	ea000003 	b	3b8bc <msdos_date_dos2unix+0x8c>                <== NOT EXECUTED
			days += months[m];                                                 
   3b8ac:	e1a05082 	lsl	r5, r2, #1                                    <== NOT EXECUTED
   3b8b0:	e19450b5 	ldrh	r5, [r4, r5]                                 <== NOT EXECUTED
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
   3b8b4:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
			days += months[m];                                                 
   3b8b8:	e0833005 	add	r3, r3, r5                                    <== NOT EXECUTED
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
   3b8bc:	e152000c 	cmp	r2, ip                                        <== NOT EXECUTED
   3b8c0:	3afffff9 	bcc	3b8ac <msdos_date_dos2unix+0x7c>              <== NOT EXECUTED
			days += months[m];                                                 
		days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;       
		lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;                  
   3b8c4:	e200001f 	and	r0, r0, #31                                   <== NOT EXECUTED
   3b8c8:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
   3b8cc:	e0803003 	add	r3, r0, r3                                    <== NOT EXECUTED
   3b8d0:	e59f0058 	ldr	r0, [pc, #88]	; 3b930 <msdos_date_dos2unix+0x100><== NOT EXECUTED
   3b8d4:	e0020390 	mul	r2, r0, r3                                    <== NOT EXECUTED
   3b8d8:	e59f3054 	ldr	r3, [pc, #84]	; 3b934 <msdos_date_dos2unix+0x104><== NOT EXECUTED
   3b8dc:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
   3b8e0:	e59f2034 	ldr	r2, [pc, #52]	; 3b91c <msdos_date_dos2unix+0xec><== NOT EXECUTED
   3b8e4:	e5823010 	str	r3, [r2, #16]                                 <== NOT EXECUTED
   3b8e8:	e59f302c 	ldr	r3, [pc, #44]	; 3b91c <msdos_date_dos2unix+0xec><== NOT EXECUTED
   3b8ec:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
   3b8f0:	e201201f 	and	r2, r1, #31                                   <== NOT EXECUTED
   3b8f4:	e2010b3e 	and	r0, r1, #63488	; 0xf800                       <== NOT EXECUTED
   3b8f8:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
   3b8fc:	e1a005a0 	lsr	r0, r0, #11                                   <== NOT EXECUTED
   3b900:	e3a0cee1 	mov	ip, #3600	; 0xe10                             <== NOT EXECUTED
   3b904:	e023209c 	mla	r3, ip, r0, r2                                <== NOT EXECUTED
   3b908:	e2011e7e 	and	r1, r1, #2016	; 0x7e0                         <== NOT EXECUTED
   3b90c:	e1a012a1 	lsr	r1, r1, #5                                    <== NOT EXECUTED
   3b910:	e3a0003c 	mov	r0, #60	; 0x3c                                <== NOT EXECUTED
	}                                                                    
	return seconds + lastseconds;                                        
}                                                                     
   3b914:	e0203091 	mla	r0, r1, r0, r3                                <== NOT EXECUTED
   3b918:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

0003b6e8 <msdos_date_unix2dos>: * file timestamps. The passed in unix time is assumed to be in GMT. */ void msdos_date_unix2dos(unsigned int t, uint16_t *ddp, uint16_t *dtp) {
   3b6e8:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * If the time from the last conversion is the same as now, then     
	 * skip the computations and use the saved result.                   
	 */                                                                  
	if (lasttime != t) {                                                 
   3b6ec:	e59f411c 	ldr	r4, [pc, #284]	; 3b810 <msdos_date_unix2dos+0x128><== NOT EXECUTED
   3b6f0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   3b6f4:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
 * file timestamps. The passed in unix time is assumed to be in GMT.  
 */                                                                   
void                                                                  
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,                    
                    uint16_t *dtp)                                    
{                                                                     
   3b6f8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   3b6fc:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   3b700:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * If the time from the last conversion is the same as now, then     
	 * skip the computations and use the saved result.                   
	 */                                                                  
	if (lasttime != t) {                                                 
   3b704:	0a00003b 	beq	3b7f8 <msdos_date_unix2dos+0x110>             <== NOT EXECUTED
		lasttime = t;                                                       
		lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)            
   3b708:	e3a0103c 	mov	r1, #60	; 0x3c                                <== NOT EXECUTED
	/*                                                                   
	 * If the time from the last conversion is the same as now, then     
	 * skip the computations and use the saved result.                   
	 */                                                                  
	if (lasttime != t) {                                                 
		lasttime = t;                                                       
   3b70c:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
		lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)            
   3b710:	eb0065b8 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   3b714:	e3a0103c 	mov	r1, #60	; 0x3c                                <== NOT EXECUTED
   3b718:	eb00664a 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   3b71c:	e3a01ee1 	mov	r1, #3600	; 0xe10                             <== NOT EXECUTED
   3b720:	e1a08280 	lsl	r8, r0, #5                                    <== NOT EXECUTED
   3b724:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3b728:	eb0065b2 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   3b72c:	e3a01018 	mov	r1, #24                                       <== NOT EXECUTED
   3b730:	eb006644 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   3b734:	e3a0103c 	mov	r1, #60	; 0x3c                                <== NOT EXECUTED
   3b738:	e0888580 	add	r8, r8, r0, lsl #11                           <== NOT EXECUTED
   3b73c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3b740:	eb006640 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   3b744:	e08880a0 	add	r8, r8, r0, lsr #1                            <== NOT EXECUTED
		/*                                                                  
		 * If the number of days since 1970 is the same as the last         
		 * time we did the computation then skip all this leap year         
		 * and month stuff.                                                 
		 */                                                                 
		days = t / (SECONDSPERDAY);                                         
   3b748:	e59f10c4 	ldr	r1, [pc, #196]	; 3b814 <msdos_date_unix2dos+0x12c><== NOT EXECUTED
   3b74c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
	 * If the time from the last conversion is the same as now, then     
	 * skip the computations and use the saved result.                   
	 */                                                                  
	if (lasttime != t) {                                                 
		lasttime = t;                                                       
		lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)            
   3b750:	e1c480b4 	strh	r8, [r4, #4]                                 <== NOT EXECUTED
		/*                                                                  
		 * If the number of days since 1970 is the same as the last         
		 * time we did the computation then skip all this leap year         
		 * and month stuff.                                                 
		 */                                                                 
		days = t / (SECONDSPERDAY);                                         
   3b754:	eb0065a7 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
		if (days != lastday) {                                              
   3b758:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   3b75c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
   3b760:	0a000024 	beq	3b7f8 <msdos_date_unix2dos+0x110>             <== NOT EXECUTED
			lastday = days;                                                    
   3b764:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
   3b768:	e59f30a8 	ldr	r3, [pc, #168]	; 3b818 <msdos_date_unix2dos+0x130><== NOT EXECUTED
			for (year = 1970;; year++) {                                       
				inc = year & 0x03 ? 365 : 366;                                    
   3b76c:	e59f40a8 	ldr	r4, [pc, #168]	; 3b81c <msdos_date_unix2dos+0x134><== NOT EXECUTED
   3b770:	e59f10a8 	ldr	r1, [pc, #168]	; 3b820 <msdos_date_unix2dos+0x138><== NOT EXECUTED
   3b774:	e213c003 	ands	ip, r3, #3                                   <== NOT EXECUTED
   3b778:	11a02004 	movne	r2, r4                                      <== NOT EXECUTED
   3b77c:	01a02001 	moveq	r2, r1                                      <== NOT EXECUTED
				if (days < inc)                                                   
   3b780:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
					break;                                                           
				days -= inc;                                                      
   3b784:	20620000 	rsbcs	r0, r2, r0                                  <== NOT EXECUTED
		 * and month stuff.                                                 
		 */                                                                 
		days = t / (SECONDSPERDAY);                                         
		if (days != lastday) {                                              
			lastday = days;                                                    
			for (year = 1970;; year++) {                                       
   3b788:	22833001 	addcs	r3, r3, #1                                  <== NOT EXECUTED
				inc = year & 0x03 ? 365 : 366;                                    
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
   3b78c:	2afffff8 	bcs	3b774 <msdos_date_unix2dos+0x8c>              <== NOT EXECUTED
			months = year & 0x03 ? regyear : leapyear;                         
   3b790:	e59f208c 	ldr	r2, [pc, #140]	; 3b824 <msdos_date_unix2dos+0x13c><== NOT EXECUTED
   3b794:	e59f108c 	ldr	r1, [pc, #140]	; 3b828 <msdos_date_unix2dos+0x140><== NOT EXECUTED
   3b798:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   3b79c:	01a0c002 	moveq	ip, r2                                      <== NOT EXECUTED
   3b7a0:	11a0c001 	movne	ip, r1                                      <== NOT EXECUTED
   3b7a4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
			for (month = 0; month < 12; month++) {                             
				if (days < months[month])                                         
   3b7a8:	e1a01082 	lsl	r1, r2, #1                                    <== NOT EXECUTED
   3b7ac:	e19c10b1 	ldrh	r1, [ip, r1]                                 <== NOT EXECUTED
   3b7b0:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
   3b7b4:	3a000003 	bcc	3b7c8 <msdos_date_unix2dos+0xe0>              <== NOT EXECUTED
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
			for (month = 0; month < 12; month++) {                             
   3b7b8:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   3b7bc:	e352000c 	cmp	r2, #12                                       <== NOT EXECUTED
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
   3b7c0:	e0610000 	rsb	r0, r1, r0                                    <== NOT EXECUTED
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
			for (month = 0; month < 12; month++) {                             
   3b7c4:	1afffff7 	bne	3b7a8 <msdos_date_unix2dos+0xc0>              <== NOT EXECUTED
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
   3b7c8:	e0802282 	add	r2, r0, r2, lsl #5                            <== NOT EXECUTED
			 * Remember dos's idea of time is relative to 1980.                
			 * unix's is relative to 1970.  If somehow we get a                
			 * time before 1980 then don't give totally crazy                  
			 * results.                                                        
			 */                                                                
			if (year > 1980)                                                   
   3b7cc:	e59f0058 	ldr	r0, [pc, #88]	; 3b82c <msdos_date_unix2dos+0x144><== NOT EXECUTED
			for (month = 0; month < 12; month++) {                             
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
   3b7d0:	e2822021 	add	r2, r2, #33	; 0x21                            <== NOT EXECUTED
			 * Remember dos's idea of time is relative to 1980.                
			 * unix's is relative to 1970.  If somehow we get a                
			 * time before 1980 then don't give totally crazy                  
			 * results.                                                        
			 */                                                                
			if (year > 1980)                                                   
   3b7d4:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
				lastddate += (year - 1980) <<                                     
   3b7d8:	82433e7b 	subhi	r3, r3, #1968	; 0x7b0                       <== NOT EXECUTED
			for (month = 0; month < 12; month++) {                             
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
   3b7dc:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
   3b7e0:	e59f1028 	ldr	r1, [pc, #40]	; 3b810 <msdos_date_unix2dos+0x128><== NOT EXECUTED
   3b7e4:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
			 * unix's is relative to 1970.  If somehow we get a                
			 * time before 1980 then don't give totally crazy                  
			 * results.                                                        
			 */                                                                
			if (year > 1980)                                                   
				lastddate += (year - 1980) <<                                     
   3b7e8:	8243300c 	subhi	r3, r3, #12                                 <== NOT EXECUTED
   3b7ec:	80823483 	addhi	r3, r2, r3, lsl #9                          <== NOT EXECUTED
			for (month = 0; month < 12; month++) {                             
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
   3b7f0:	e1c120bc 	strh	r2, [r1, #12]                                <== NOT EXECUTED
			 * unix's is relative to 1970.  If somehow we get a                
			 * time before 1980 then don't give totally crazy                  
			 * results.                                                        
			 */                                                                
			if (year > 1980)                                                   
				lastddate += (year - 1980) <<                                     
   3b7f4:	81c130bc 	strhhi	r3, [r1, #12]                              <== NOT EXECUTED
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
   3b7f8:	e59f3010 	ldr	r3, [pc, #16]	; 3b810 <msdos_date_unix2dos+0x128><== NOT EXECUTED
   3b7fc:	e1d320b4 	ldrh	r2, [r3, #4]                                 <== NOT EXECUTED
   3b800:	e1c720b0 	strh	r2, [r7]                                     <== NOT EXECUTED
	*ddp = lastddate;                                                    
   3b804:	e1d330bc 	ldrh	r3, [r3, #12]                                <== NOT EXECUTED
   3b808:	e1c630b0 	strh	r3, [r6]                                     <== NOT EXECUTED
}                                                                     
   3b80c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0003ba94 <msdos_dir_chmod>: int msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc, mode_t mode) { return RC_OK; }
   3ba94:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3ba98:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0003c1b0 <msdos_dir_close>: int msdos_dir_close(rtems_libio_t *iop) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   3c1b0:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 *     RC_OK, if directory closed successfully, or -1 if error occured (errno
 *     set apropriately.                                              
 */                                                                   
int                                                                   
msdos_dir_close(rtems_libio_t *iop)                                   
{                                                                     
   3c1b4:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   3c1b8:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3c1bc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     RC_OK, if directory closed successfully, or -1 if error occured (errno
 *     set apropriately.                                              
 */                                                                   
int                                                                   
msdos_dir_close(rtems_libio_t *iop)                                   
{                                                                     
   3c1c0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3c1c4:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   3c1c8:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
msdos_dir_close(rtems_libio_t *iop)                                   
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   3c1cc:	e5956038 	ldr	r6, [r5, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3c1d0:	ebff3dba 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   3c1d4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c1d8:	0a000004 	beq	3c1f0 <msdos_dir_close+0x40>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
   3c1dc:	eb000347 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3c1e0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3c1e4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3c1e8:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   3c1ec:	ea000005 	b	3c208 <msdos_dir_close+0x58>                    <== NOT EXECUTED
                                                                      
    rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);              
   3c1f0:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
   3c1f4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3c1f8:	ebff982e 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   3c1fc:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   3c200:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3c204:	ebff3df3 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   3c208:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3c20c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00032818 <msdos_dir_is_empty>: msdos_dir_is_empty( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd, bool *ret_val ) {
   32818:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         j = 0, i = 0;                                    
                                                                      
    /* dir is not empty */                                            
    *ret_val = false;                                                 
   3281c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
msdos_dir_is_empty(                                                   
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd,                     
    bool                                 *ret_val                     
    )                                                                 
{                                                                     
   32820:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
   32824:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   32828:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         j = 0, i = 0;                                    
                                                                      
    /* dir is not empty */                                            
    *ret_val = false;                                                 
   3282c:	e5c26000 	strb	r6, [r2]                                     <== NOT EXECUTED
    fat_file_fd_t                        *fat_fd,                     
    bool                                 *ret_val                     
    )                                                                 
{                                                                     
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   32830:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t         j = 0, i = 0;                                    
                                                                      
    /* dir is not empty */                                            
    *ret_val = false;                                                 
                                                                      
    while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
   32834:	ea00002d 	b	328f0 <msdos_dir_is_empty+0xd8>                 <== NOT EXECUTED
                                  fs_info->fat.vol.bps,               
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
   32838:	e350001f 	cmp	r0, #31                                       <== NOT EXECUTED
   3283c:	d3e00000 	mvnle	r0, #0                                      <== NOT EXECUTED
   32840:	da000036 	ble	32920 <msdos_dir_is_empty+0x108>              <== NOT EXECUTED
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
   32844:	e1d490b0 	ldrh	r9, [r4]                                     <== NOT EXECUTED
   32848:	e1500009 	cmp	r0, r9                                        <== NOT EXECUTED
   3284c:	0a000023 	beq	328e0 <msdos_dir_is_empty+0xc8>               <== NOT EXECUTED
   32850:	e59f00cc 	ldr	r0, [pc, #204]	; 32924 <msdos_dir_is_empty+0x10c><== NOT EXECUTED
   32854:	e59f10cc 	ldr	r1, [pc, #204]	; 32928 <msdos_dir_is_empty+0x110><== NOT EXECUTED
   32858:	e59f20cc 	ldr	r2, [pc, #204]	; 3292c <msdos_dir_is_empty+0x114><== NOT EXECUTED
   3285c:	e59f30cc 	ldr	r3, [pc, #204]	; 32930 <msdos_dir_is_empty+0x118><== NOT EXECUTED
   32860:	ebffc8f3 	bl	24c34 <__assert_func>                          <== NOT EXECUTED
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
             i < fs_info->fat.vol.bps;                                
             i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
   32864:	e594a098 	ldr	sl, [r4, #152]	; 0x98                         <== NOT EXECUTED
             * then consider it as empty.                             
             *                                                        
             * Just ignore long file name entries. They must have a short entry to
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
   32868:	e7da8007 	ldrb	r8, [sl, r7]                                 <== NOT EXECUTED
   3286c:	e35800e5 	cmp	r8, #229	; 0xe5                               <== NOT EXECUTED
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
             i < fs_info->fat.vol.bps;                                
             i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
   32870:	e08aa007 	add	sl, sl, r7                                    <== NOT EXECUTED
             * then consider it as empty.                             
             *                                                        
             * Just ignore long file name entries. They must have a short entry to
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
   32874:	0a000011 	beq	328c0 <msdos_dir_is_empty+0xa8>               <== NOT EXECUTED
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
   32878:	e5da300b 	ldrb	r3, [sl, #11]                                <== NOT EXECUTED
   3287c:	e203303f 	and	r3, r3, #63	; 0x3f                            <== NOT EXECUTED
   32880:	e353000f 	cmp	r3, #15                                       <== NOT EXECUTED
   32884:	0a00000d 	beq	328c0 <msdos_dir_is_empty+0xa8>               <== NOT EXECUTED
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
   32888:	e59f30a4 	ldr	r3, [pc, #164]	; 32934 <msdos_dir_is_empty+0x11c><== NOT EXECUTED
   3288c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   32890:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
   32894:	e3a0200b 	mov	r2, #11                                       <== NOT EXECUTED
   32898:	eb0044df 	bl	43c1c <strncmp>                                <== NOT EXECUTED
             * then consider it as empty.                             
             *                                                        
             * Just ignore long file name entries. They must have a short entry to
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
   3289c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   328a0:	0a000006 	beq	328c0 <msdos_dir_is_empty+0xa8>               <== NOT EXECUTED
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
   328a4:	e59f3088 	ldr	r3, [pc, #136]	; 32934 <msdos_dir_is_empty+0x11c><== NOT EXECUTED
   328a8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   328ac:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
   328b0:	e3a0200b 	mov	r2, #11                                       <== NOT EXECUTED
   328b4:	eb0044d8 	bl	43c1c <strncmp>                                <== NOT EXECUTED
             * then consider it as empty.                             
             *                                                        
             * Just ignore long file name entries. They must have a short entry to
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
   328b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   328bc:	1a000001 	bne	328c8 <msdos_dir_is_empty+0xb0>               <== NOT EXECUTED
        assert(ret == fs_info->fat.vol.bps);                          
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
             i < fs_info->fat.vol.bps;                                
             i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
   328c0:	e2877020 	add	r7, r7, #32                                   <== NOT EXECUTED
   328c4:	ea000006 	b	328e4 <msdos_dir_is_empty+0xcc>                 <== NOT EXECUTED
                continue;                                             
                                                                      
            /*                                                        
             * Nothing more to look at.                               
             */                                                       
            if ((*MSDOS_DIR_NAME(entry)) ==                           
   328c8:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
            {                                                         
                *ret_val = true;                                      
   328cc:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
                continue;                                             
                                                                      
            /*                                                        
             * Nothing more to look at.                               
             */                                                       
            if ((*MSDOS_DIR_NAME(entry)) ==                           
   328d0:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
            {                                                         
                *ret_val = true;                                      
   328d4:	05c53000 	strbeq	r3, [r5]                                   <== NOT EXECUTED
   328d8:	01a00008 	moveq	r0, r8                                      <== NOT EXECUTED
                return RC_OK;                                         
   328dc:	ea00000f 	b	32920 <msdos_dir_is_empty+0x108>                <== NOT EXECUTED
   328e0:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
   328e4:	e1570009 	cmp	r7, r9                                        <== NOT EXECUTED
   328e8:	3affffdd 	bcc	32864 <msdos_dir_is_empty+0x4c>               <== NOT EXECUTED
            /*                                                        
             * Short file name entries mean not empty.                
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
   328ec:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
    uint32_t         j = 0, i = 0;                                    
                                                                      
    /* dir is not empty */                                            
    *ret_val = false;                                                 
                                                                      
    while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
   328f0:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
   328f4:	e594c098 	ldr	ip, [r4, #152]	; 0x98                         <== NOT EXECUTED
   328f8:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
   328fc:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   32900:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   32904:	e0020296 	mul	r2, r6, r2                                    <== NOT EXECUTED
   32908:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   3290c:	ebffbdef 	bl	220d0 <fat_file_read>                          <== NOT EXECUTED
   32910:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32914:	1affffc7 	bne	32838 <msdos_dir_is_empty+0x20>               <== NOT EXECUTED
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
    }                                                                 
    *ret_val = true;                                                  
   32918:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3291c:	e5c53000 	strb	r3, [r5]                                     <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   32920:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
                                                                      

0003ba9c <msdos_dir_lseek>: * set apropriately). */ rtems_off64_t msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence) { switch (whence)
   3ba9c:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
 *     RC_OK on success, or -1 if error occured (errno                
 *     set apropriately).                                             
 */                                                                   
rtems_off64_t                                                         
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence) 
{                                                                     
   3baa0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
    switch (whence)                                                   
   3baa4:	93a03000 	movls	r3, #0                                      <== NOT EXECUTED
   3baa8:	93a04000 	movls	r4, #0                                      <== NOT EXECUTED
   3baac:	9a000004 	bls	3bac4 <msdos_dir_lseek+0x28>                  <== NOT EXECUTED
         * Movement past the end of the directory via lseek is not a  
         * permitted operation                                        
         */                                                           
        case SEEK_END:                                                
        default:                                                      
            rtems_set_errno_and_return_minus_one( EINVAL );           
   3bab0:	eb000512 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bab4:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   3bab8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3babc:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   3bac0:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
            break;                                                    
    }                                                                 
    return RC_OK;                                                     
}                                                                     
   3bac4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   3bac8:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   3bacc:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

0003c210 <msdos_dir_open>: msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   3c210:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 *     set apropriately)                                              
 */                                                                   
int                                                                   
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t   flag,
               uint32_t   mode)                                       
{                                                                     
   3c214:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   3c218:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3c21c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     set apropriately)                                              
 */                                                                   
int                                                                   
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t   flag,
               uint32_t   mode)                                       
{                                                                     
   3c220:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3c224:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   3c228:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
               uint32_t   mode)                                       
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   3c22c:	e5956038 	ldr	r6, [r5, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3c230:	ebff3da2 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   3c234:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c238:	0a000004 	beq	3c250 <msdos_dir_open+0x40>                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
   3c23c:	eb00032f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3c240:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3c244:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3c248:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
   3c24c:	ea000008 	b	3c274 <msdos_dir_open+0x64>                     <== NOT EXECUTED
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
   3c250:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3c254:	ebff958a 	bl	21884 <fat_file_reopen>                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   3c258:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    iop->offset = 0;                                                  
   3c25c:	03a02000 	moveq	r2, #0                                      <== NOT EXECUTED
   3c260:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   3c264:	0585200c 	streq	r2, [r5, #12]                               <== NOT EXECUTED
   3c268:	05853010 	streq	r3, [r5, #16]                               <== NOT EXECUTED
    rtems_semaphore_release(fs_info->vol_sema);                       
   3c26c:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3c270:	ebff3dd8 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   3c274:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3c278:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

0003bcb8 <msdos_dir_read>: * the number of bytes read on success, or -1 if error occured (errno * set apropriately). */ ssize_t msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count) {
   3bcb8:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   3bcbc:	e590a038 	ldr	sl, [r0, #56]	; 0x38                          <== NOT EXECUTED
 *     the number of bytes read on success, or -1 if error occured (errno
 *     set apropriately).                                             
 */                                                                   
ssize_t                                                               
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)        
{                                                                     
   3bcc0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
     * optimization: we know that root directory for FAT12/16 volumes is
     * sequential set of sectors and any cluster is sequential set of sectors
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
   3bcc4:	e59a0020 	ldr	r0, [sl, #32]                                 <== NOT EXECUTED
ssize_t                                                               
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)        
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   3bcc8:	e5973028 	ldr	r3, [r7, #40]	; 0x28                          <== NOT EXECUTED
 *     the number of bytes read on success, or -1 if error occured (errno
 *     set apropriately).                                             
 */                                                                   
ssize_t                                                               
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)        
{                                                                     
   3bccc:	e24dde15 	sub	sp, sp, #336	; 0x150                          <== NOT EXECUTED
     * optimization: we know that root directory for FAT12/16 volumes is
     * sequential set of sectors and any cluster is sequential set of sectors
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
   3bcd0:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
 *     the number of bytes read on success, or -1 if error occured (errno
 *     set apropriately).                                             
 */                                                                   
ssize_t                                                               
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)        
{                                                                     
   3bcd4:	e58d1024 	str	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
   3bcd8:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   3bcdc:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
    /*                                                                
     * cast start and count - protect against using sizes that are not exact
     * multiples of the -dirent- size. These could result in unexpected
     * results                                                        
     */                                                               
    start = iop->offset / sizeof(struct dirent);                      
   3bce0:	e287900c 	add	r9, r7, #12                                   <== NOT EXECUTED
   3bce4:	e8990300 	ldm	r9, {r8, r9}                                  <== NOT EXECUTED
     * optimization: we know that root directory for FAT12/16 volumes is
     * sequential set of sectors and any cluster is sequential set of sectors
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
   3bce8:	1a000007 	bne	3bd0c <msdos_dir_read+0x54>                   <== NOT EXECUTED
   3bcec:	e59a3024 	ldr	r3, [sl, #36]	; 0x24                          <== NOT EXECUTED
   3bcf0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3bcf4:	1a000004 	bne	3bd0c <msdos_dir_read+0x54>                   <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
   3bcf8:	e5d5300a 	ldrb	r3, [r5, #10]                                <== NOT EXECUTED
   3bcfc:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
     * optimization: we know that root directory for FAT12/16 volumes is
     * sequential set of sectors and any cluster is sequential set of sectors
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
   3bd00:	159a0018 	ldrne	r0, [sl, #24]                               <== NOT EXECUTED
   3bd04:	158d001c 	strne	r0, [sp, #28]                               <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
   3bd08:	1a000001 	bne	3bd14 <msdos_dir_read+0x5c>                   <== NOT EXECUTED
     * optimization: we know that root directory for FAT12/16 volumes is
     * sequential set of sectors and any cluster is sequential set of sectors
     * too, so read such set of sectors is quick operation for low-level IO
     * layer.                                                         
     */                                                               
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
   3bd0c:	e1d510b6 	ldrh	r1, [r5, #6]                                 <== NOT EXECUTED
   3bd10:	e58d101c 	str	r1, [sp, #28]                                 <== NOT EXECUTED
    uint32_t           start = 0;                                     
    ssize_t            ret = 0;                                       
    uint32_t           cmpltd = 0;                                    
    uint32_t           j = 0, i = 0;                                  
    uint32_t           bts2rd = 0;                                    
    uint32_t           cur_cln = 0;                                   
   3bd14:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
             fs_info->fat.vol.bpc;                                    
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bd18:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   3bd1c:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   3bd20:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    uint32_t           start = 0;                                     
    ssize_t            ret = 0;                                       
    uint32_t           cmpltd = 0;                                    
    uint32_t           j = 0, i = 0;                                  
    uint32_t           bts2rd = 0;                                    
    uint32_t           cur_cln = 0;                                   
   3bd24:	e58d3148 	str	r3, [sp, #328]	; 0x148                        <== NOT EXECUTED
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    fat_file_fd_t     *tmp_fat_fd = NULL;                             
   3bd28:	e58d314c 	str	r3, [sp, #332]	; 0x14c                        <== NOT EXECUTED
    bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&                           
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
             fs_info->fat.vol.bpc;                                    
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bd2c:	ebff3ee3 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   3bd30:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   3bd34:	1a000020 	bne	3bdbc <msdos_dir_read+0x104>                  <== NOT EXECUTED
    /*                                                                
     * cast start and count - protect against using sizes that are not exact
     * multiples of the -dirent- size. These could result in unexpected
     * results                                                        
     */                                                               
    start = iop->offset / sizeof(struct dirent);                      
   3bd38:	e3a02e11 	mov	r2, #272	; 0x110                              <== NOT EXECUTED
   3bd3c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   3bd40:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   3bd44:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   3bd48:	eb0065d8 	bl	554b0 <__divdi3>                               <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
   3bd4c:	e3a01e11 	mov	r1, #272	; 0x110                              <== NOT EXECUTED
    /*                                                                
     * cast start and count - protect against using sizes that are not exact
     * multiples of the -dirent- size. These could result in unexpected
     * results                                                        
     */                                                               
    start = iop->offset / sizeof(struct dirent);                      
   3bd50:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
   3bd54:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3bd58:	eb006426 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   3bd5c:	e3a03e11 	mov	r3, #272	; 0x110                              <== NOT EXECUTED
   3bd60:	e0000093 	mul	r0, r3, r0                                    <== NOT EXECUTED
   3bd64:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
   3bd68:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
   3bd6c:	e58d6010 	str	r6, [sp, #16]                                 <== NOT EXECUTED
   3bd70:	e1a0b006 	mov	fp, r6                                        <== NOT EXECUTED
   3bd74:	e58d6018 	str	r6, [sp, #24]                                 <== NOT EXECUTED
   3bd78:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
   3bd7c:	e1a08005 	mov	r8, r5                                        <== NOT EXECUTED
   3bd80:	ea0000f3 	b	3c154 <msdos_dir_read+0x49c>                    <== NOT EXECUTED
         * fat-file is already opened by open call, so read it        
         * Always read directory fat-file from the beggining because of MSDOS
         * directories feature :( - we should count elements currently
         * present in the directory because there may be holes :)     
         */                                                           
        ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
   3bd84:	e598c098 	ldr	ip, [r8, #152]	; 0x98                         <== NOT EXECUTED
   3bd88:	e5970028 	ldr	r0, [r7, #40]	; 0x28                          <== NOT EXECUTED
   3bd8c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   3bd90:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   3bd94:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   3bd98:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   3bd9c:	ebff98cb 	bl	220d0 <fat_file_read>                          <== NOT EXECUTED
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
   3bda0:	e350001f 	cmp	r0, #31                                       <== NOT EXECUTED
         * fat-file is already opened by open call, so read it        
         * Always read directory fat-file from the beggining because of MSDOS
         * directories feature :( - we should count elements currently
         * present in the directory because there may be holes :)     
         */                                                           
        ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
   3bda4:	e58d0020 	str	r0, [sp, #32]                                 <== NOT EXECUTED
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
   3bda8:	c3a05000 	movgt	r5, #0                                      <== NOT EXECUTED
   3bdac:	ca0000e3 	bgt	3c140 <msdos_dir_read+0x488>                  <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
   3bdb0:	e5980094 	ldr	r0, [r8, #148]	; 0x94                         <== NOT EXECUTED
   3bdb4:	e1a05008 	mov	r5, r8                                        <== NOT EXECUTED
   3bdb8:	ebff3f06 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
   3bdbc:	eb00044f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bdc0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3bdc4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3bdc8:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   3bdcc:	ea0000e7 	b	3c170 <msdos_dir_read+0x4b8>                    <== NOT EXECUTED
        }                                                             
                                                                      
        for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)  
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
   3bdd0:	e5984098 	ldr	r4, [r8, #152]	; 0x98                         <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
   3bdd4:	e7d43005 	ldrb	r3, [r4, r5]                                 <== NOT EXECUTED
   3bdd8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
        }                                                             
                                                                      
        for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)  
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
   3bddc:	e0844005 	add	r4, r4, r5                                    <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
   3bde0:	01a05008 	moveq	r5, r8                                      <== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
            {                                                         
                rtems_semaphore_release(fs_info->vol_sema);           
   3bde4:	05980094 	ldreq	r0, [r8, #148]	; 0x94                       <== NOT EXECUTED
                return cmpltd;                                        
   3bde8:	059d3010 	ldreq	r3, [sp, #16]                               <== NOT EXECUTED
   3bdec:	0a0000c4 	beq	3c104 <msdos_dir_read+0x44c>                  <== NOT EXECUTED
            }                                                         
                                                                      
            /* Is the directory entry empty */                        
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
   3bdf0:	e35300e5 	cmp	r3, #229	; 0xe5                               <== NOT EXECUTED
   3bdf4:	0a0000d0 	beq	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                continue;                                             
                                                                      
            /* Is the directory entry empty a volume label */         
            if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&  
   3bdf8:	e5d4200b 	ldrb	r2, [r4, #11]                                <== NOT EXECUTED
   3bdfc:	e3120008 	tst	r2, #8                                        <== NOT EXECUTED
   3be00:	0a000002 	beq	3be10 <msdos_dir_read+0x158>                  <== NOT EXECUTED
   3be04:	e202103f 	and	r1, r2, #63	; 0x3f                            <== NOT EXECUTED
   3be08:	e351000f 	cmp	r1, #15                                       <== NOT EXECUTED
   3be0c:	1a0000ca 	bne	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                                                                      
            /*                                                        
             * Check the attribute to see if the entry is for a long file
             * name.                                                  
             */                                                       
            if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==     
   3be10:	e202203f 	and	r2, r2, #63	; 0x3f                            <== NOT EXECUTED
   3be14:	e352000f 	cmp	r2, #15                                       <== NOT EXECUTED
   3be18:	1a000031 	bne	3bee4 <msdos_dir_read+0x22c>                  <== NOT EXECUTED
                int   q;                                              
                                                                      
                /*                                                    
                 * Is this is the first entry of a LFN ?              
                 */                                                   
                if (lfn_start == FAT_FILE_SHORT_NAME)                 
   3be1c:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
   3be20:	e37c0001 	cmn	ip, #1                                        <== NOT EXECUTED
   3be24:	1a00000b 	bne	3be58 <msdos_dir_read+0x1a0>                  <== NOT EXECUTED
                {                                                     
                    /*                                                
                     * The first entry must have the last long entry flag set.
                     */                                               
                    if ((*MSDOS_DIR_ENTRY_TYPE(entry) &               
   3be28:	e3130040 	tst	r3, #64	; 0x40                                <== NOT EXECUTED
   3be2c:	0a0000c2 	beq	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                        continue;                                     
                                                                      
                    /*                                                
                     * Remember the start location of the long file name.
                     */                                               
                    lfn_start =                                       
   3be30:	e085c006 	add	ip, r5, r6                                    <== NOT EXECUTED
   3be34:	e1a0c2ac 	lsr	ip, ip, #5                                    <== NOT EXECUTED
   3be38:	e58dc00c 	str	ip, [sp, #12]                                 <== NOT EXECUTED
                     * Get the number of entries so we can count down and
                     * also the checksum of the short entry.          
                     */                                               
                    lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &     
                                   MSDOS_LAST_LONG_ENTRY_MASK);       
                    lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);    
   3be3c:	e5d4e00d 	ldrb	lr, [r4, #13]                                <== NOT EXECUTED
                    memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
   3be40:	e28d0038 	add	r0, sp, #56	; 0x38                            <== NOT EXECUTED
   3be44:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   3be48:	e28220f1 	add	r2, r2, #241	; 0xf1                           <== NOT EXECUTED
                                                                      
                    /*                                                
                     * Get the number of entries so we can count down and
                     * also the checksum of the short entry.          
                     */                                               
                    lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &     
   3be4c:	e203b03f 	and	fp, r3, #63	; 0x3f                            <== NOT EXECUTED
                                   MSDOS_LAST_LONG_ENTRY_MASK);       
                    lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);    
   3be50:	e58de018 	str	lr, [sp, #24]                                 <== NOT EXECUTED
                    memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
   3be54:	eb001160 	bl	403dc <memset>                                 <== NOT EXECUTED
                 * If the entry number or the check sum do not match  
                 * forget this series of long directory entries. These could
                 * be orphaned entries depending on the history of the
                 * disk.                                              
                 */                                                   
                if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &   
   3be58:	e5d43000 	ldrb	r3, [r4]                                     <== NOT EXECUTED
   3be5c:	e203303f 	and	r3, r3, #63	; 0x3f                            <== NOT EXECUTED
   3be60:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
   3be64:	1a0000b2 	bne	3c134 <msdos_dir_read+0x47c>                  <== NOT EXECUTED
                                     MSDOS_LAST_LONG_ENTRY_MASK)) ||  
                    (lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry))) 
   3be68:	e5d4300d 	ldrb	r3, [r4, #13]                                <== NOT EXECUTED
   3be6c:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
   3be70:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
   3be74:	1a0000ae 	bne	3c134 <msdos_dir_read+0x47c>                  <== NOT EXECUTED
                 * fit in the directory entry name field.             
                 */                                                   
                                                                      
                lfn_entries--;                                        
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
   3be78:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
                 * The DOS maximum length is 255 characters without the
                 * trailing nul character. We need to range check the length to
                 * fit in the directory entry name field.             
                 */                                                   
                                                                      
                lfn_entries--;                                        
   3be7c:	e24bb001 	sub	fp, fp, #1                                    <== NOT EXECUTED
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
   3be80:	e0020b93 	mul	r2, r3, fp                                    <== NOT EXECUTED
   3be84:	e28d3e15 	add	r3, sp, #336	; 0x150                          <== NOT EXECUTED
   3be88:	e0831002 	add	r1, r3, r2                                    <== NOT EXECUTED
                 * trailing nul character. We need to range check the length to
                 * fit in the directory entry name field.             
                 */                                                   
                                                                      
                lfn_entries--;                                        
                p = entry + 1;                                        
   3be8c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
   3be90:	e2411f46 	sub	r1, r1, #280	; 0x118                          <== NOT EXECUTED
   3be94:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                                                                      
                for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)         
                {                                                     
                    if (o >= (sizeof(tmp_dirent.d_name) - 1))         
   3be98:	e35200fe 	cmp	r2, #254	; 0xfe                               <== NOT EXECUTED
   3be9c:	8a0000a6 	bhi	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                        break;                                        
                                                                      
                    tmp_dirent.d_name[o++] = *p;                      
   3bea0:	e5d40000 	ldrb	r0, [r4]                                     <== NOT EXECUTED
   3bea4:	e5c10000 	strb	r0, [r1]                                     <== NOT EXECUTED
                                                                      
                    if (*p == '\0')                                   
   3bea8:	e5d40000 	ldrb	r0, [r4]                                     <== NOT EXECUTED
   3beac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3beb0:	0a0000a1 	beq	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                        break;                                        
                                                                      
                    switch (q)                                        
   3beb4:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
                    {                                                 
                        case 4:                                       
                            p += 5;                                   
   3beb8:	02844005 	addeq	r4, r4, #5                                  <== NOT EXECUTED
                    tmp_dirent.d_name[o++] = *p;                      
                                                                      
                    if (*p == '\0')                                   
                        break;                                        
                                                                      
                    switch (q)                                        
   3bebc:	0a000002 	beq	3becc <msdos_dir_read+0x214>                  <== NOT EXECUTED
   3bec0:	e353000a 	cmp	r3, #10                                       <== NOT EXECUTED
                            break;                                    
                        case 10:                                      
                            p += 4;                                   
                            break;                                    
                        default:                                      
                            p += 2;                                   
   3bec4:	12844002 	addne	r4, r4, #2                                  <== NOT EXECUTED
                    {                                                 
                        case 4:                                       
                            p += 5;                                   
                            break;                                    
                        case 10:                                      
                            p += 4;                                   
   3bec8:	02844004 	addeq	r4, r4, #4                                  <== NOT EXECUTED
                                                                      
                lfn_entries--;                                        
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
                                                                      
                for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)         
   3becc:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3bed0:	e353000d 	cmp	r3, #13                                       <== NOT EXECUTED
   3bed4:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
   3bed8:	0a000097 	beq	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                {                                                     
                    if (o >= (sizeof(tmp_dirent.d_name) - 1))         
                        break;                                        
                                                                      
                    tmp_dirent.d_name[o++] = *p;                      
   3bedc:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   3bee0:	eaffffec 	b	3be98 <msdos_dir_read+0x1e0>                    <== NOT EXECUTED
                fat_dir_pos_t dir_pos;                                
                                                                      
                /*                                                    
                 * Skip active entries until get the entry to start from.
                 */                                                   
                if (start)                                            
   3bee4:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
                {                                                     
                    lfn_start = FAT_FILE_SHORT_NAME;                  
                    start--;                                          
   3bee8:	13e0c000 	mvnne	ip, #0                                      <== NOT EXECUTED
   3beec:	12499001 	subne	r9, r9, #1                                  <== NOT EXECUTED
   3bef0:	158dc00c 	strne	ip, [sp, #12]                               <== NOT EXECUTED
                    continue;                                         
   3bef4:	1a000090 	bne	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
                 * unfortunately there is no method to extract ino except to
                 * open fat-file descriptor :( ... so, open it        
                 */                                                   
                                                                      
                /* get number of cluster we are working with */       
                rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
   3bef8:	e5970028 	ldr	r0, [r7, #40]	; 0x28                          <== NOT EXECUTED
   3befc:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   3bf00:	e28def52 	add	lr, sp, #328	; 0x148                          <== NOT EXECUTED
   3bf04:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   3bf08:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3bf0c:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
   3bf10:	ebff9701 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                    j * bts2rd, &cur_cln);            
                if (rc != RC_OK)                                      
   3bf14:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   3bf18:	1a000077 	bne	3c0fc <msdos_dir_read+0x444>                  <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
                                                                      
                fat_dir_pos_init(&dir_pos);                           
                dir_pos.sname.cln = cur_cln;                          
   3bf1c:	e59d3148 	ldr	r3, [sp, #328]	; 0x148                        <== NOT EXECUTED
                dir_pos.sname.ofs = i;                                
                rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
   3bf20:	e5970028 	ldr	r0, [r7, #40]	; 0x28                          <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
                                                                      
                fat_dir_pos_init(&dir_pos);                           
                dir_pos.sname.cln = cur_cln;                          
   3bf24:	e58d3138 	str	r3, [sp, #312]	; 0x138                        <== NOT EXECUTED
                dir_pos.sname.ofs = i;                                
                rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
   3bf28:	e28d1f4e 	add	r1, sp, #312	; 0x138                          <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   3bf2c:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   3bf30:	e28d2f53 	add	r2, sp, #332	; 0x14c                          <== NOT EXECUTED
   3bf34:	e58d3140 	str	r3, [sp, #320]	; 0x140                        <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
   3bf38:	e58d3144 	str	r3, [sp, #324]	; 0x144                        <== NOT EXECUTED
                    return rc;                                        
                }                                                     
                                                                      
                fat_dir_pos_init(&dir_pos);                           
                dir_pos.sname.cln = cur_cln;                          
                dir_pos.sname.ofs = i;                                
   3bf3c:	e58d513c 	str	r5, [sp, #316]	; 0x13c                        <== NOT EXECUTED
                rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
   3bf40:	ebff9905 	bl	2235c <fat_file_open>                          <== NOT EXECUTED
                if (rc != RC_OK)                                      
   3bf44:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   3bf48:	1a00006b 	bne	3c0fc <msdos_dir_read+0x444>                  <== NOT EXECUTED
                                                                      
                /* fill in dirent structure */                        
                /* XXX: from what and in what d_off should be computed ?! */
                tmp_dirent.d_off = start + cmpltd;                    
                tmp_dirent.d_reclen = sizeof(struct dirent);          
                tmp_dirent.d_ino = tmp_fat_fd->ino;                   
   3bf4c:	e59d314c 	ldr	r3, [sp, #332]	; 0x14c                        <== NOT EXECUTED
                /*                                                    
                 * If a long file name check if the correct number of 
                 * entries have been found and if the checksum is correct.
                 * If not return the short file name.                 
                 */                                                   
                if (lfn_start != FAT_FILE_SHORT_NAME)                 
   3bf50:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
                                                                      
                /* fill in dirent structure */                        
                /* XXX: from what and in what d_off should be computed ?! */
                tmp_dirent.d_off = start + cmpltd;                    
                tmp_dirent.d_reclen = sizeof(struct dirent);          
                tmp_dirent.d_ino = tmp_fat_fd->ino;                   
   3bf54:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
                }                                                     
                                                                      
                /* fill in dirent structure */                        
                /* XXX: from what and in what d_off should be computed ?! */
                tmp_dirent.d_off = start + cmpltd;                    
                tmp_dirent.d_reclen = sizeof(struct dirent);          
   3bf58:	e59f2248 	ldr	r2, [pc, #584]	; 3c1a8 <msdos_dir_read+0x4f0> <== NOT EXECUTED
                    return rc;                                        
                }                                                     
                                                                      
                /* fill in dirent structure */                        
                /* XXX: from what and in what d_off should be computed ?! */
                tmp_dirent.d_off = start + cmpltd;                    
   3bf5c:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
                tmp_dirent.d_reclen = sizeof(struct dirent);          
   3bf60:	e3a0ee11 	mov	lr, #272	; 0x110                              <== NOT EXECUTED
   3bf64:	e28d0e15 	add	r0, sp, #336	; 0x150                          <== NOT EXECUTED
                /*                                                    
                 * If a long file name check if the correct number of 
                 * entries have been found and if the checksum is correct.
                 * If not return the short file name.                 
                 */                                                   
                if (lfn_start != FAT_FILE_SHORT_NAME)                 
   3bf68:	e37c0001 	cmn	ip, #1                                        <== NOT EXECUTED
                }                                                     
                                                                      
                /* fill in dirent structure */                        
                /* XXX: from what and in what d_off should be computed ?! */
                tmp_dirent.d_off = start + cmpltd;                    
                tmp_dirent.d_reclen = sizeof(struct dirent);          
   3bf6c:	e180e0b2 	strh	lr, [r0, r2]                                 <== NOT EXECUTED
                tmp_dirent.d_ino = tmp_fat_fd->ino;                   
   3bf70:	e58d3028 	str	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
                    return rc;                                        
                }                                                     
                                                                      
                /* fill in dirent structure */                        
                /* XXX: from what and in what d_off should be computed ?! */
                tmp_dirent.d_off = start + cmpltd;                    
   3bf74:	e58d102c 	str	r1, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   3bf78:	e58d9030 	str	r9, [sp, #48]	; 0x30                          <== NOT EXECUTED
                /*                                                    
                 * If a long file name check if the correct number of 
                 * entries have been found and if the checksum is correct.
                 * If not return the short file name.                 
                 */                                                   
                if (lfn_start != FAT_FILE_SHORT_NAME)                 
   3bf7c:	0a000016 	beq	3bfdc <msdos_dir_read+0x324>                  <== NOT EXECUTED
   3bf80:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   3bf84:	e1a03009 	mov	r3, r9                                        <== NOT EXECUTED
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
   3bf88:	e7d40002 	ldrb	r0, [r4, r2]                                 <== NOT EXECUTED
   3bf8c:	e2131001 	ands	r1, r3, #1                                   <== NOT EXECUTED
   3bf90:	13a01080 	movne	r1, #128	; 0x80                             <== NOT EXECUTED
   3bf94:	e08030a3 	add	r3, r0, r3, lsr #1                            <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
   3bf98:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
   3bf9c:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
   3bfa0:	e352000b 	cmp	r2, #11                                       <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
   3bfa4:	e20330ff 	and	r3, r3, #255	; 0xff                           <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
   3bfa8:	1afffff6 	bne	3bf88 <msdos_dir_read+0x2d0>                  <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
                                                                      
                    if (lfn_entries || (lfn_checksum != cs))          
   3bfac:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
   3bfb0:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
   3bfb4:	01520003 	cmpeq	r2, r3                                      <== NOT EXECUTED
   3bfb8:	1a000007 	bne	3bfdc <msdos_dir_read+0x324>                  <== NOT EXECUTED
   3bfbc:	ea00006e 	b	3c17c <msdos_dir_read+0x4c4>                    <== NOT EXECUTED
   3bfc0:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
  const char *src_tmp;                                                
                                                                      
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
   3bfc4:	e2533001 	subs	r3, r3, #1                                   <== NOT EXECUTED
   3bfc8:	2a000004 	bcs	3bfe0 <msdos_dir_read+0x328>                  <== NOT EXECUTED
   3bfcc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3bfd0:	e28d3038 	add	r3, sp, #56	; 0x38                            <== NOT EXECUTED
   3bfd4:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
   3bfd8:	ea000010 	b	3c020 <msdos_dir_read+0x368>                    <== NOT EXECUTED
   3bfdc:	e3a03007 	mov	r3, #7                                        <== NOT EXECUTED
   3bfe0:	e7d42003 	ldrb	r2, [r4, r3]                                 <== NOT EXECUTED
   3bfe4:	e3520020 	cmp	r2, #32                                       <== NOT EXECUTED
   3bfe8:	e2831001 	add	r1, r3, #1                                    <== NOT EXECUTED
   3bfec:	0afffff3 	beq	3bfc0 <msdos_dir_read+0x308>                  <== NOT EXECUTED
   3bff0:	eafffff5 	b	3bfcc <msdos_dir_read+0x314>                    <== NOT EXECUTED
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
   3bff4:	e59fe1b0 	ldr	lr, [pc, #432]	; 3c1ac <msdos_dir_read+0x4f4> <== NOT EXECUTED
   3bff8:	e59ee000 	ldr	lr, [lr]                                      <== NOT EXECUTED
   3bffc:	e7d4c000 	ldrb	ip, [r4, r0]                                 <== NOT EXECUTED
   3c000:	e58de004 	str	lr, [sp, #4]                                  <== NOT EXECUTED
   3c004:	e08ee00c 	add	lr, lr, ip                                    <== NOT EXECUTED
   3c008:	e5dee001 	ldrb	lr, [lr, #1]                                 <== NOT EXECUTED
   3c00c:	e20ee003 	and	lr, lr, #3                                    <== NOT EXECUTED
   3c010:	e35e0001 	cmp	lr, #1                                        <== NOT EXECUTED
   3c014:	028cc020 	addeq	ip, ip, #32                                 <== NOT EXECUTED
   3c018:	e4c3c001 	strb	ip, [r3], #1                                 <== NOT EXECUTED
   3c01c:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
 * RETURNS:                                                           
 *     the number of bytes read on success, or -1 if error occured (errno
 *     set apropriately).                                             
 */                                                                   
ssize_t                                                               
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)        
   3c020:	e060c001 	rsb	ip, r0, r1                                    <== NOT EXECUTED
  /*                                                                  
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
   3c024:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   3c028:	cafffff1 	bgt	3bff4 <msdos_dir_read+0x33c>                  <== NOT EXECUTED
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
  }                                                                   
  /*                                                                  
   * find last non-blank character of extension                       
   */                                                                 
  for ((i       =                            MSDOS_SHORT_EXT_LEN  ,   
   3c02c:	e5d4000a 	ldrb	r0, [r4, #10]                                <== NOT EXECUTED
   3c030:	e3500020 	cmp	r0, #32                                       <== NOT EXECUTED
   3c034:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   3c038:	13a00003 	movne	r0, #3                                      <== NOT EXECUTED
   3c03c:	1a000053 	bne	3c190 <msdos_dir_read+0x4d8>                  <== NOT EXECUTED
   3c040:	e5d40009 	ldrb	r0, [r4, #9]                                 <== NOT EXECUTED
   3c044:	e3500020 	cmp	r0, #32                                       <== NOT EXECUTED
	src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);         
       ((i > 0) &&                                                    
	(*src_tmp == ' '));                                                  
       i--,src_tmp--)                                                 
   3c048:	e2840009 	add	r0, r4, #9                                    <== NOT EXECUTED
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
  }                                                                   
  /*                                                                  
   * find last non-blank character of extension                       
   */                                                                 
  for ((i       =                            MSDOS_SHORT_EXT_LEN  ,   
   3c04c:	13a00002 	movne	r0, #2                                      <== NOT EXECUTED
   3c050:	1a00004e 	bne	3c190 <msdos_dir_read+0x4d8>                  <== NOT EXECUTED
   3c054:	e5500001 	ldrb	r0, [r0, #-1]                                <== NOT EXECUTED
   3c058:	e3500020 	cmp	r0, #32                                       <== NOT EXECUTED
   3c05c:	0a00000e 	beq	3c09c <msdos_dir_read+0x3e4>                  <== NOT EXECUTED
   3c060:	ea000049 	b	3c18c <msdos_dir_read+0x4d4>                    <== NOT EXECUTED
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
   3c064:	e59fe140 	ldr	lr, [pc, #320]	; 3c1ac <msdos_dir_read+0x4f4> <== NOT EXECUTED
   3c068:	e5d40008 	ldrb	r0, [r4, #8]                                 <== NOT EXECUTED
   3c06c:	e59ec000 	ldr	ip, [lr]                                      <== NOT EXECUTED
   3c070:	e08cc000 	add	ip, ip, r0                                    <== NOT EXECUTED
   3c074:	e5dcc001 	ldrb	ip, [ip, #1]                                 <== NOT EXECUTED
   3c078:	e20cc003 	and	ip, ip, #3                                    <== NOT EXECUTED
   3c07c:	e35c0001 	cmp	ip, #1                                        <== NOT EXECUTED
   3c080:	02800020 	addeq	r0, r0, #32                                 <== NOT EXECUTED
   3c084:	e4c30001 	strb	r0, [r3], #1                                 <== NOT EXECUTED
      len++;                                                          
   3c088:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   3c08c:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
   3c090:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
   3c094:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   3c098:	cafffff1 	bgt	3c064 <msdos_dir_read+0x3ac>                  <== NOT EXECUTED
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
      len++;                                                          
    }                                                                 
  }                                                                   
  *dst = '\0'; /* terminate string */                                 
   3c09c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                {                                                     
                    /*                                                
                     * convert dir entry from fixed 8+3 format (without dot)
                     * to 0..8 + 1dot + 0..3 format                   
                     */                                               
                    tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
   3c0a0:	e3e01000 	mvn	r1, #0                                        <== NOT EXECUTED
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
      len++;                                                          
    }                                                                 
  }                                                                   
  *dst = '\0'; /* terminate string */                                 
   3c0a4:	e5c30000 	strb	r0, [r3]                                     <== NOT EXECUTED
                {                                                     
                    /*                                                
                     * convert dir entry from fixed 8+3 format (without dot)
                     * to 0..8 + 1dot + 0..3 format                   
                     */                                               
                    tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
   3c0a8:	e1cd23b6 	strh	r2, [sp, #54]	; 0x36                         <== NOT EXECUTED
   3c0ac:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
                else                                                  
                {                                                     
                    tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);  
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
   3c0b0:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   3c0b4:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
   3c0b8:	e28d1028 	add	r1, sp, #40	; 0x28                            <== NOT EXECUTED
   3c0bc:	e083000c 	add	r0, r3, ip                                    <== NOT EXECUTED
   3c0c0:	e3a02e11 	mov	r2, #272	; 0x110                              <== NOT EXECUTED
   3c0c4:	eb00103d 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
   3c0c8:	e287400c 	add	r4, r7, #12                                   <== NOT EXECUTED
   3c0cc:	e8940018 	ldm	r4, {r3, r4}                                  <== NOT EXECUTED
   3c0d0:	e3a01e11 	mov	r1, #272	; 0x110                              <== NOT EXECUTED
   3c0d4:	e0933001 	adds	r3, r3, r1                                   <== NOT EXECUTED
   3c0d8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   3c0dc:	e0a44002 	adc	r4, r4, r2                                    <== NOT EXECUTED
   3c0e0:	e587300c 	str	r3, [r7, #12]                                 <== NOT EXECUTED
   3c0e4:	e5874010 	str	r4, [r7, #16]                                 <== NOT EXECUTED
                cmpltd += (sizeof(struct dirent));                    
                count -= (sizeof(struct dirent));                     
                                                                      
                /* inode number extracted, close fat-file */          
                rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
   3c0e8:	e5970028 	ldr	r0, [r7, #40]	; 0x28                          <== NOT EXECUTED
   3c0ec:	e59d114c 	ldr	r1, [sp, #332]	; 0x14c                        <== NOT EXECUTED
   3c0f0:	ebff9870 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
                if (rc != RC_OK)                                      
   3c0f4:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   3c0f8:	0a000005 	beq	3c114 <msdos_dir_read+0x45c>                  <== NOT EXECUTED
                {                                                     
                    rtems_semaphore_release(fs_info->vol_sema);       
   3c0fc:	e5980094 	ldr	r0, [r8, #148]	; 0x94                         <== NOT EXECUTED
   3c100:	e1a05008 	mov	r5, r8                                        <== NOT EXECUTED
   3c104:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   3c108:	ebff3e32 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
                    return rc;                                        
   3c10c:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   3c110:	ea000016 	b	3c170 <msdos_dir_read+0x4b8>                    <== NOT EXECUTED
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
   3c114:	e28d0010 	add	r0, sp, #16                                   <== NOT EXECUTED
   3c118:	e8904001 	ldm	r0, {r0, lr}                                  <== NOT EXECUTED
   3c11c:	e25eee11 	subs	lr, lr, #272	; 0x110                         <== NOT EXECUTED
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
                cmpltd += (sizeof(struct dirent));                    
   3c120:	e2800e11 	add	r0, r0, #272	; 0x110                          <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
   3c124:	e58de014 	str	lr, [sp, #20]                                 <== NOT EXECUTED
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
                cmpltd += (sizeof(struct dirent));                    
   3c128:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
   3c12c:	1a000002 	bne	3c13c <msdos_dir_read+0x484>                  <== NOT EXECUTED
   3c130:	ea000005 	b	3c14c <msdos_dir_read+0x494>                    <== NOT EXECUTED
   3c134:	e3e01000 	mvn	r1, #0                                        <== NOT EXECUTED
   3c138:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
            rtems_set_errno_and_return_minus_one(EIO);                
        }                                                             
                                                                      
        for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)  
   3c13c:	e2855020 	add	r5, r5, #32                                   <== NOT EXECUTED
   3c140:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
   3c144:	e1550002 	cmp	r5, r2                                        <== NOT EXECUTED
   3c148:	3affff20 	bcc	3bdd0 <msdos_dir_read+0x118>                  <== NOT EXECUTED
   3c14c:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   3c150:	e0866003 	add	r6, r6, r3                                    <== NOT EXECUTED
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    while (count > 0)                                                 
   3c154:	e59dc014 	ldr	ip, [sp, #20]                                 <== NOT EXECUTED
   3c158:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   3c15c:	1affff08 	bne	3bd84 <msdos_dir_read+0xcc>                   <== NOT EXECUTED
                break;                                                
        }                                                             
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   3c160:	e5980094 	ldr	r0, [r8, #148]	; 0x94                         <== NOT EXECUTED
   3c164:	ebff3e1b 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return cmpltd;                                                    
   3c168:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   3c16c:	e1a05008 	mov	r5, r8                                        <== NOT EXECUTED
}                                                                     
   3c170:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   3c174:	e28dde15 	add	sp, sp, #336	; 0x150                          <== NOT EXECUTED
   3c178:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                    tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
                        tmp_dirent.d_name, entry); /* src text */     
                }                                                     
                else                                                  
                {                                                     
                    tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);  
   3c17c:	e28d0038 	add	r0, sp, #56	; 0x38                            <== NOT EXECUTED
   3c180:	eb001e5b 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   3c184:	e1cd03b6 	strh	r0, [sp, #54]	; 0x36                         <== NOT EXECUTED
   3c188:	eaffffc8 	b	3c0b0 <msdos_dir_read+0x3f8>                    <== NOT EXECUTED
   3c18c:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
   3c190:	e2812001 	add	r2, r1, #1                                    <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
   3c194:	e3a0102e 	mov	r1, #46	; 0x2e                                <== NOT EXECUTED
   3c198:	e4c31001 	strb	r1, [r3], #1                                 <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
   3c19c:	e0822000 	add	r2, r2, r0                                    <== NOT EXECUTED
   3c1a0:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   3c1a4:	eaffffba 	b	3c094 <msdos_dir_read+0x3dc>                    <== NOT EXECUTED
                                                                      

0003bb78 <msdos_dir_rmnod>: * RC_OK on success, or -1 if error occured (errno set apropriately). */ int msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc, rtems_filesystem_location_info_t *pathloc) {
   3bb78:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
   3bb7c:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
   3bb80:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
    bool               is_empty = false;                              
   3bb84:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
 *     RC_OK on success, or -1 if error occured (errno set apropriately).
 */                                                                   
int                                                                   
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,     
                rtems_filesystem_location_info_t *pathloc)            
{                                                                     
   3bb88:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
    bool               is_empty = false;                              
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bb8c:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3bb90:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   3bb94:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
    bool               is_empty = false;                              
   3bb98:	e5cd3003 	strb	r3, [sp, #3]                                 <== NOT EXECUTED
                rtems_filesystem_location_info_t *pathloc)            
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
   3bb9c:	e5956000 	ldr	r6, [r5]                                      <== NOT EXECUTED
    bool               is_empty = false;                              
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bba0:	ebff3f46 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   3bba4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3bba8:	0a000002 	beq	3bbb8 <msdos_dir_rmnod+0x40>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   3bbac:	eb0004d3 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bbb0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3bbb4:	ea000006 	b	3bbd4 <msdos_dir_rmnod+0x5c>                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * We deny attempts to delete open directory (if directory is current
     * directory we assume it is open one)                            
     */                                                               
    if (fat_fd->links_num > 1)                                        
   3bbb8:	e5963008 	ldr	r3, [r6, #8]                                  <== NOT EXECUTED
   3bbbc:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   3bbc0:	9a000006 	bls	3bbe0 <msdos_dir_rmnod+0x68>                  <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
   3bbc4:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3bbc8:	ebff3f82 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EBUSY);                  
   3bbcc:	eb0004cb 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bbd0:	e3a03010 	mov	r3, #16                                       <== NOT EXECUTED
   3bbd4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3bbd8:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   3bbdc:	ea00001b 	b	3bc50 <msdos_dir_rmnod+0xd8>                    <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * You cannot remove a node that still has children               
     */                                                               
    rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);    
   3bbe0:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
   3bbe4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3bbe8:	e28d2003 	add	r2, sp, #3                                    <== NOT EXECUTED
   3bbec:	ebffdb09 	bl	32818 <msdos_dir_is_empty>                     <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   3bbf0:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   3bbf4:	1a000013 	bne	3bc48 <msdos_dir_rmnod+0xd0>                  <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    if (!is_empty)                                                    
   3bbf8:	e5dd3003 	ldrb	r3, [sp, #3]                                 <== NOT EXECUTED
   3bbfc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3bc00:	1a000004 	bne	3bc18 <msdos_dir_rmnod+0xa0>                  <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
   3bc04:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3bc08:	ebff3f72 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOTEMPTY);              
   3bc0c:	eb0004bb 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bc10:	e3a0305a 	mov	r3, #90	; 0x5a                                <== NOT EXECUTED
   3bc14:	eaffffee 	b	3bbd4 <msdos_dir_rmnod+0x5c>                    <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * You cannot remove the file system root node.                   
     */                                                               
    if (pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access)
   3bc18:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
   3bc1c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   3bc20:	e590201c 	ldr	r2, [r0, #28]                                 <== NOT EXECUTED
   3bc24:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   3bc28:	0affffe5 	beq	3bbc4 <msdos_dir_rmnod+0x4c>                  <== NOT EXECUTED
     * You cannot remove a mountpoint.                                
     * not used - mount() not implemenetd yet.                        
     */                                                               
                                                                      
    /* mark file removed */                                           
    rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
   3bc2c:	e2861020 	add	r1, r6, #32                                   <== NOT EXECUTED
   3bc30:	e3a020e5 	mov	r2, #229	; 0xe5                               <== NOT EXECUTED
   3bc34:	ebffdb8a 	bl	32a64 <msdos_set_first_char4file_name>         <== NOT EXECUTED
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
    if (rc != RC_OK)                                                  
   3bc38:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    fat_file_mark_removed(pathloc->mt_entry, fat_fd);                 
   3bc3c:	05950010 	ldreq	r0, [r5, #16]                               <== NOT EXECUTED
   3bc40:	01a01006 	moveq	r1, r6                                      <== NOT EXECUTED
   3bc44:	0bff97a1 	bleq	21ad0 <fat_file_mark_removed>                <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   3bc48:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3bc4c:	ebff3f61 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   3bc50:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   3bc54:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      <== NOT EXECUTED
                                                                      

0003bad0 <msdos_dir_stat>: rtems_filesystem_location_info_t *loc, struct stat *buf ) { rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
   3bad0:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
int                                                                   
msdos_dir_stat(                                                       
    rtems_filesystem_location_info_t *loc,                            
    struct stat                      *buf                             
    )                                                                 
{                                                                     
   3bad4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
   3bad8:	e5925034 	ldr	r5, [r2, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
msdos_dir_stat(                                                       
    rtems_filesystem_location_info_t *loc,                            
    struct stat                      *buf                             
    )                                                                 
{                                                                     
   3badc:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
    fat_file_fd_t     *fat_fd = loc->node_access;                     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bae0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
int                                                                   
msdos_dir_stat(                                                       
    rtems_filesystem_location_info_t *loc,                            
    struct stat                      *buf                             
    )                                                                 
{                                                                     
   3bae4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
    fat_file_fd_t     *fat_fd = loc->node_access;                     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bae8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   3baec:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
    struct stat                      *buf                             
    )                                                                 
{                                                                     
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
    fat_file_fd_t     *fat_fd = loc->node_access;                     
   3baf0:	e5936000 	ldr	r6, [r3]                                      <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3baf4:	ebff3f71 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   3baf8:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   3bafc:	0a000004 	beq	3bb14 <msdos_dir_stat+0x44>                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   3bb00:	eb0004fe 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bb04:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3bb08:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3bb0c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   3bb10:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
    buf->st_dev = fs_info->fat.vol.dev;                               
    buf->st_ino = fat_fd->ino;                                        
   3bb14:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   3bb18:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
   3bb1c:	e59f3050 	ldr	r3, [pc, #80]	; 3bb74 <msdos_dir_stat+0xa4>   <== NOT EXECUTED
   3bb20:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
   3bb24:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
    buf->st_blksize = fs_info->fat.vol.bps;                           
   3bb28:	e1d520b0 	ldrh	r2, [r5]                                     <== NOT EXECUTED
    buf->st_dev = fs_info->fat.vol.dev;                               
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
   3bb2c:	e1a014a3 	lsr	r1, r3, #9                                    <== NOT EXECUTED
   3bb30:	e5841044 	str	r1, [r4, #68]	; 0x44                          <== NOT EXECUTED
    buf->st_blksize = fs_info->fat.vol.bps;                           
   3bb34:	e5842040 	str	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
    buf->st_mtime = fat_fd->mtime;                                    
   3bb38:	e5962040 	ldr	r2, [r6, #64]	; 0x40                          <== NOT EXECUTED
   3bb3c:	e5842030 	str	r2, [r4, #48]	; 0x30                          <== NOT EXECUTED
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = fs_info->fat.vol.dev;                               
   3bb40:	e2852054 	add	r2, r5, #84	; 0x54                            <== NOT EXECUTED
   3bb44:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
   3bb48:	e8840006 	stm	r4, {r1, r2}                                  <== NOT EXECUTED
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
   3bb4c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   3bb50:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   3bb54:	e5841018 	str	r1, [r4, #24]                                 <== NOT EXECUTED
   3bb58:	e584201c 	str	r2, [r4, #28]                                 <== NOT EXECUTED
    buf->st_size = fat_fd->fat_file_size;                             
   3bb5c:	e5843020 	str	r3, [r4, #32]                                 <== NOT EXECUTED
   3bb60:	e5847024 	str	r7, [r4, #36]	; 0x24                          <== NOT EXECUTED
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
    buf->st_blksize = fs_info->fat.vol.bps;                           
    buf->st_mtime = fat_fd->mtime;                                    
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   3bb64:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   3bb68:	ebff3f9a 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
   3bb6c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   3bb70:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

0003bc58 <msdos_dir_sync>: msdos_dir_sync(rtems_libio_t *iop) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; fat_file_fd_t *fat_fd = iop->file_info; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   3bc58:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set apropriately).
 */                                                                   
int                                                                   
msdos_dir_sync(rtems_libio_t *iop)                                    
{                                                                     
   3bc5c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   3bc60:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bc64:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set apropriately).
 */                                                                   
int                                                                   
msdos_dir_sync(rtems_libio_t *iop)                                    
{                                                                     
   3bc68:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bc6c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   3bc70:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
int                                                                   
msdos_dir_sync(rtems_libio_t *iop)                                    
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   3bc74:	e5946038 	ldr	r6, [r4, #56]	; 0x38                          <== NOT EXECUTED
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3bc78:	ebff3f10 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   3bc7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3bc80:	0a000004 	beq	3bc98 <msdos_dir_sync+0x40>                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   3bc84:	eb00049d 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3bc88:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3bc8c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3bc90:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   3bc94:	ea000005 	b	3bcb0 <msdos_dir_sync+0x58>                     <== NOT EXECUTED
                                                                      
    rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);           
   3bc98:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   3bc9c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3bca0:	ebff974a 	bl	219d0 <fat_file_datasync>                      <== NOT EXECUTED
   3bca4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   3bca8:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   3bcac:	ebff3f49 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   3bcb0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3bcb4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

000314b0 <msdos_eval4make>: msdos_eval4make( const char *path, rtems_filesystem_location_info_t *pathloc, const char **name ) {
   314b0:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
    int                               rc = RC_OK;                     
    rtems_status_code                 sc = RTEMS_SUCCESSFUL;          
    msdos_fs_info_t                  *fs_info = pathloc->mt_entry->fs_info;
   314b4:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
   314b8:	e593a034 	ldr	sl, [r3, #52]	; 0x34                          <== NOT EXECUTED
msdos_eval4make(                                                      
    const char                         *path,                         
    rtems_filesystem_location_info_t   *pathloc,                      
    const char                        **name                          
    )                                                                 
{                                                                     
   314bc:	e24dd020 	sub	sp, sp, #32                                   <== NOT EXECUTED
   314c0:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    int                               i = 0;                          
    int                               token_len;                      
    const char                       *token;                          
    bool                              done = false;                   
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   314c4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
msdos_eval4make(                                                      
    const char                         *path,                         
    rtems_filesystem_location_info_t   *pathloc,                      
    const char                        **name                          
    )                                                                 
{                                                                     
   314c8:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
   314cc:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    int                               i = 0;                          
    int                               token_len;                      
    const char                       *token;                          
    bool                              done = false;                   
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   314d0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   314d4:	e59a0094 	ldr	r0, [sl, #148]	; 0x94                         <== NOT EXECUTED
   314d8:	ebff68f8 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   314dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   314e0:	0a000004 	beq	314f8 <msdos_eval4make+0x48>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   314e4:	eb002e85 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   314e8:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   314ec:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   314f0:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   314f4:	ea000086 	b	31714 <msdos_eval4make+0x264>                   <== NOT EXECUTED
                                                                      
    if (!pathloc->node_access)                                        
   314f8:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   314fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31500:	1a000004 	bne	31518 <msdos_eval4make+0x68>                  <== NOT EXECUTED
    {                                                                 
        errno = ENOENT;                                               
   31504:	eb002e7d 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31508:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   3150c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31510:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
        rc = -1;                                                      
        goto err;                                                     
   31514:	ea00007c 	b	3170c <msdos_eval4make+0x25c>                   <== NOT EXECUTED
    }                                                                 
                                                                      
    fat_fd = pathloc->node_access;                                    
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
   31518:	ebffc0d9 	bl	21884 <fat_file_reopen>                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   3151c:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   31520:	1a000079 	bne	3170c <msdos_eval4make+0x25c>                 <== NOT EXECUTED
                    /*                                                
                     *  Am I at the root of all filesystems?          
                     *  XXX: MSDOS is not supposed to be base fs.     
                     */                                               
                    if (pathloc->node_access ==                       
                        rtems_filesystem_root.node_access)            
   31524:	e59f91f4 	ldr	r9, [pc, #500]	; 31720 <msdos_eval4make+0x270><== NOT EXECUTED
    }                                                                 
                                                                      
    fat_fd = pathloc->node_access;                                    
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
    if (rc != RC_OK)                                                  
   31528:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
        goto err;                                                     
                                                                      
    while (!done)                                                     
    {                                                                 
        type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
   3152c:	e0878006 	add	r8, r7, r6                                    <== NOT EXECUTED
   31530:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   31534:	eb00496e 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   31538:	e28d2018 	add	r2, sp, #24                                   <== NOT EXECUTED
   3153c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   31540:	e28d301c 	add	r3, sp, #28                                   <== NOT EXECUTED
   31544:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   31548:	eb0005dc 	bl	32cc0 <msdos_get_token>                        <== NOT EXECUTED
        i += token_len;                                               
        fat_fd = pathloc->node_access;                                
   3154c:	e594e000 	ldr	lr, [r4]                                      <== NOT EXECUTED
        goto err;                                                     
                                                                      
    while (!done)                                                     
    {                                                                 
        type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
        i += token_len;                                               
   31550:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
        fat_fd = pathloc->node_access;                                
   31554:	e1a0800e 	mov	r8, lr                                        <== NOT EXECUTED
        goto err;                                                     
                                                                      
    while (!done)                                                     
    {                                                                 
        type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
        i += token_len;                                               
   31558:	e0866002 	add	r6, r6, r2                                    <== NOT EXECUTED
        fat_fd = pathloc->node_access;                                
                                                                      
        switch (type)                                                 
   3155c:	e3500004 	cmp	r0, #4                                        <== NOT EXECUTED
   31560:	979ff100 	ldrls	pc, [pc, r0, lsl #2]                        <== NOT EXECUTED
   31564:	eafffff0 	b	3152c <msdos_eval4make+0x7c>                    <== NOT EXECUTED
   31568:	0003167c 	.word	0x0003167c                                  <== NOT EXECUTED
   3156c:	0003152c 	.word	0x0003152c                                  <== NOT EXECUTED
   31570:	0003157c 	.word	0x0003157c                                  <== NOT EXECUTED
   31574:	0003164c 	.word	0x0003164c                                  <== NOT EXECUTED
   31578:	00031688 	.word	0x00031688                                  <== NOT EXECUTED
        {                                                             
            case MSDOS_UP_DIR:                                        
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   3157c:	e59e3010 	ldr	r3, [lr, #16]                                 <== NOT EXECUTED
   31580:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                              pathloc, name);
                    }                                                 
                }                                                     
                else                                                  
                {                                                     
                    rc = msdos_find_name(pathloc, token, token_len);  
   31584:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
        {                                                             
            case MSDOS_UP_DIR:                                        
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   31588:	1a000053 	bne	316dc <msdos_eval4make+0x22c>                 <== NOT EXECUTED
                                                                      
                /*                                                    
                 *  Am I at the root of this mounted filesystem?      
                 */                                                   
                if (pathloc->node_access ==                           
                    pathloc->mt_entry->mt_fs_root.node_access)        
   3158c:	e594c010 	ldr	ip, [r4, #16]                                 <== NOT EXECUTED
                }                                                     
                                                                      
                /*                                                    
                 *  Am I at the root of this mounted filesystem?      
                 */                                                   
                if (pathloc->node_access ==                           
   31590:	e59c301c 	ldr	r3, [ip, #28]                                 <== NOT EXECUTED
   31594:	e15e0003 	cmp	lr, r3                                        <== NOT EXECUTED
   31598:	1a00001f 	bne	3161c <msdos_eval4make+0x16c>                 <== NOT EXECUTED
                    /*                                                
                     *  Am I at the root of all filesystems?          
                     *  XXX: MSDOS is not supposed to be base fs.     
                     */                                               
                    if (pathloc->node_access ==                       
                        rtems_filesystem_root.node_access)            
   3159c:	e5993000 	ldr	r3, [r9]                                      <== NOT EXECUTED
   315a0:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
   315a4:	e15e0003 	cmp	lr, r3                                        <== NOT EXECUTED
   315a8:	0affffdf 	beq	3152c <msdos_eval4make+0x7c>                  <== NOT EXECUTED
                    {                                                 
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
   315ac:	e28cc008 	add	ip, ip, #8                                    <== NOT EXECUTED
   315b0:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   315b4:	e28d8004 	add	r8, sp, #4                                    <== NOT EXECUTED
   315b8:	e8a8000f 	stmia	r8!, {r0, r1, r2, r3}                       <== NOT EXECUTED
                        *pathloc = newloc;                            
   315bc:	e28d5004 	add	r5, sp, #4                                    <== NOT EXECUTED
   315c0:	e8b5000f 	ldm	r5!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   315c4:	e1a05004 	mov	r5, r4                                        <== NOT EXECUTED
                    {                                                 
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
   315c8:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
                        *pathloc = newloc;                            
   315cc:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       <== NOT EXECUTED
                                                                      
                        rc = fat_file_close(pathloc->mt_entry, fat_fd);
   315d0:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
                        *pathloc = newloc;                            
   315d4:	e585c000 	str	ip, [r5]                                      <== NOT EXECUTED
                                                                      
                        rc = fat_file_close(pathloc->mt_entry, fat_fd);
   315d8:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
                    {                                                 
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
   315dc:	e588c000 	str	ip, [r8]                                      <== NOT EXECUTED
                        *pathloc = newloc;                            
                                                                      
                        rc = fat_file_close(pathloc->mt_entry, fat_fd);
   315e0:	ebffc334 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
                        if (rc != RC_OK)                              
   315e4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   315e8:	1a000047 	bne	3170c <msdos_eval4make+0x25c>                 <== NOT EXECUTED
                            goto err;                                 
                                                                      
                        rtems_semaphore_release(fs_info->vol_sema);   
   315ec:	e59a0094 	ldr	r0, [sl, #148]	; 0x94                         <== NOT EXECUTED
   315f0:	ebff68f8 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
                        return (*pathloc->ops->evalformake_h)(&path[i-token_len],
   315f4:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   315f8:	e0636006 	rsb	r6, r3, r6                                    <== NOT EXECUTED
   315fc:	e0870006 	add	r0, r7, r6                                    <== NOT EXECUTED
   31600:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   31604:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   31608:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   3160c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   31610:	e593f004 	ldr	pc, [r3, #4]                                  <== NOT EXECUTED
   31614:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   31618:	ea00003d 	b	31714 <msdos_eval4make+0x264>                   <== NOT EXECUTED
                                                              pathloc, name);
                    }                                                 
                }                                                     
                else                                                  
                {                                                     
                    rc = msdos_find_name(pathloc, token, token_len);  
   3161c:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
   31620:	eb0006ff 	bl	33224 <msdos_find_name>                        <== NOT EXECUTED
                    if (rc != RC_OK)                                  
   31624:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   31628:	0affffbf 	beq	3152c <msdos_eval4make+0x7c>                  <== NOT EXECUTED
                    {                                                 
                        if (rc == MSDOS_NAME_NOT_FOUND_ERR)           
   3162c:	e59f30f0 	ldr	r3, [pc, #240]	; 31724 <msdos_eval4make+0x274><== NOT EXECUTED
   31630:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
   31634:	1a000030 	bne	316fc <msdos_eval4make+0x24c>                 <== NOT EXECUTED
                        {                                             
                            errno = ENOENT;                           
   31638:	eb002e30 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3163c:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   31640:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31644:	e3e0b000 	mvn	fp, #0                                        <== NOT EXECUTED
   31648:	ea00002b 	b	316fc <msdos_eval4make+0x24c>                   <== NOT EXECUTED
                                                                      
            case MSDOS_NAME:                                          
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   3164c:	e59e3010 	ldr	r3, [lr, #16]                                 <== NOT EXECUTED
   31650:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                                      
                /*                                                    
                 * Otherwise find the token name in the present location and
                 * set the node access to the point we have found.    
                 */                                                   
                rc = msdos_find_name(pathloc, token, token_len);      
   31654:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
            case MSDOS_NAME:                                          
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   31658:	1a00001f 	bne	316dc <msdos_eval4make+0x22c>                 <== NOT EXECUTED
                                                                      
                /*                                                    
                 * Otherwise find the token name in the present location and
                 * set the node access to the point we have found.    
                 */                                                   
                rc = msdos_find_name(pathloc, token, token_len);      
   3165c:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
   31660:	eb0006ef 	bl	33224 <msdos_find_name>                        <== NOT EXECUTED
                if (rc)                                               
   31664:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31668:	0affffaf 	beq	3152c <msdos_eval4make+0x7c>                  <== NOT EXECUTED
                {                                                     
                    if (rc != MSDOS_NAME_NOT_FOUND_ERR)               
   3166c:	e59f30b0 	ldr	r3, [pc, #176]	; 31724 <msdos_eval4make+0x274><== NOT EXECUTED
   31670:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
   31674:	0a000006 	beq	31694 <msdos_eval4make+0x1e4>                 <== NOT EXECUTED
   31678:	eaffffee 	b	31638 <msdos_eval4make+0x188>                   <== NOT EXECUTED
                        done = true;                                  
                }                                                     
                break;                                                
                                                                      
            case MSDOS_NO_MORE_PATH:                                  
                errno = EEXIST;                                       
   3167c:	eb002e1f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31680:	e3a03011 	mov	r3, #17                                       <== NOT EXECUTED
   31684:	eaffffed 	b	31640 <msdos_eval4make+0x190>                   <== NOT EXECUTED
                                                                      
            case MSDOS_CURRENT_DIR:                                   
                break;                                                
                                                                      
            case MSDOS_INVALID_TOKEN:                                 
                errno = ENAMETOOLONG;                                 
   31688:	eb002e1c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3168c:	e3a0305b 	mov	r3, #91	; 0x5b                                <== NOT EXECUTED
   31690:	eaffffea 	b	31640 <msdos_eval4make+0x190>                   <== NOT EXECUTED
                break;                                                
                                                                      
        }                                                             
    }                                                                 
                                                                      
    *name = &path[i - token_len];                                     
   31694:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   31698:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   3169c:	e0633006 	rsb	r3, r3, r6                                    <== NOT EXECUTED
   316a0:	e0873003 	add	r3, r7, r3                                    <== NOT EXECUTED
   316a4:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
   316a8:	e0876006 	add	r6, r7, r6                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * 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++)                                      
   316ac:	ea000003 	b	316c0 <msdos_eval4make+0x210>                   <== NOT EXECUTED
    {                                                                 
        if (!msdos_is_separator(path[i]))                             
   316b0:	ebff5e34 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   316b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   316b8:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   316bc:	0affffdd 	beq	31638 <msdos_eval4make+0x188>                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * 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++)                                      
   316c0:	e5d63000 	ldrb	r3, [r6]                                     <== NOT EXECUTED
   316c4:	e2530000 	subs	r0, r3, #0                                   <== NOT EXECUTED
   316c8:	1afffff8 	bne	316b0 <msdos_eval4make+0x200>                 <== NOT EXECUTED
            rc = -1;                                                  
            goto error;                                               
        }                                                             
    }                                                                 
                                                                      
    fat_fd = pathloc->node_access;                                    
   316cc:	e5948000 	ldr	r8, [r4]                                      <== NOT EXECUTED
                                                                      
    if (fat_fd->fat_file_type != FAT_DIRECTORY)                       
   316d0:	e5983010 	ldr	r3, [r8, #16]                                 <== NOT EXECUTED
   316d4:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   316d8:	0a000002 	beq	316e8 <msdos_eval4make+0x238>                 <== NOT EXECUTED
    {                                                                 
        errno = ENOTDIR;                                              
   316dc:	eb002e07 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   316e0:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   316e4:	eaffffd5 	b	31640 <msdos_eval4make+0x190>                   <== NOT EXECUTED
{                                                                     
    msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;                
    fat_file_fd_t   *fat_fd = loc->node_access;                       
                                                                      
    if (fat_fd->fat_file_type == FAT_DIRECTORY)                       
        loc->handlers = fs_info->directory_handlers;                  
   316e8:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   316ec:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          <== NOT EXECUTED
   316f0:	e593308c 	ldr	r3, [r3, #140]	; 0x8c                         <== NOT EXECUTED
   316f4:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
   316f8:	ea000003 	b	3170c <msdos_eval4make+0x25c>                   <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return RC_OK;                                                     
                                                                      
error:                                                                
    fat_file_close(pathloc->mt_entry, fat_fd);                        
   316fc:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31700:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   31704:	ebffc2eb 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   31708:	e1a0500b 	mov	r5, fp                                        <== NOT EXECUTED
                                                                      
err:                                                                  
    rtems_semaphore_release(fs_info->vol_sema);                       
   3170c:	e59a0094 	ldr	r0, [sl, #148]	; 0x94                         <== NOT EXECUTED
   31710:	ebff68b0 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   31714:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   31718:	e28dd020 	add	sp, sp, #32                                   <== NOT EXECUTED
   3171c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0003125c <msdos_eval_path>: const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) {
   3125c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   31260:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
    int                               rc = RC_OK;                     
    rtems_status_code                 sc = RTEMS_SUCCESSFUL;          
    msdos_fs_info_t                  *fs_info = pathloc->mt_entry->fs_info;
   31264:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
   31268:	e5939034 	ldr	r9, [r3, #52]	; 0x34                          <== NOT EXECUTED
    const char                        *pathname,                      
    size_t                             pathnamelen,                   
    int                                flags,                         
    rtems_filesystem_location_info_t  *pathloc                        
    )                                                                 
{                                                                     
   3126c:	e24dd024 	sub	sp, sp, #36	; 0x24                            <== NOT EXECUTED
    rtems_status_code                 sc = RTEMS_SUCCESSFUL;          
    msdos_fs_info_t                  *fs_info = pathloc->mt_entry->fs_info;
    fat_file_fd_t                    *fat_fd = NULL;                  
    rtems_filesystem_location_info_t  newloc;                         
    int                               i = 0;                          
    int                               token_len = 0;                  
   31270:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    const char                        *pathname,                      
    size_t                             pathnamelen,                   
    int                                flags,                         
    rtems_filesystem_location_info_t  *pathloc                        
    )                                                                 
{                                                                     
   31274:	e88d0005 	stm	sp, {r0, r2}                                  <== NOT EXECUTED
   31278:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
    int                               i = 0;                          
    int                               token_len = 0;                  
    msdos_token_types_t               type = MSDOS_CURRENT_DIR;       
    const char                       *token;                          
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3127c:	e5990094 	ldr	r0, [r9, #148]	; 0x94                         <== NOT EXECUTED
   31280:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   31284:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    rtems_status_code                 sc = RTEMS_SUCCESSFUL;          
    msdos_fs_info_t                  *fs_info = pathloc->mt_entry->fs_info;
    fat_file_fd_t                    *fat_fd = NULL;                  
    rtems_filesystem_location_info_t  newloc;                         
    int                               i = 0;                          
    int                               token_len = 0;                  
   31288:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
    msdos_token_types_t               type = MSDOS_CURRENT_DIR;       
    const char                       *token;                          
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3128c:	ebff698b 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31290:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31294:	0a000004 	beq	312ac <msdos_eval_path+0x50>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31298:	eb002f18 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3129c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   312a0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   312a4:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   312a8:	ea00007b 	b	3149c <msdos_eval_path+0x240>                   <== NOT EXECUTED
                                                                      
    if (!pathloc->node_access)                                        
   312ac:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   312b0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   312b4:	1a000004 	bne	312cc <msdos_eval_path+0x70>                  <== NOT EXECUTED
    {                                                                 
        errno = ENOENT;                                               
   312b8:	eb002f10 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   312bc:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   312c0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   312c4:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
        rc = -1;                                                      
        goto err;                                                     
   312c8:	ea000071 	b	31494 <msdos_eval_path+0x238>                   <== NOT EXECUTED
    }                                                                 
                                                                      
    fat_fd = pathloc->node_access;                                    
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
   312cc:	ebffc16c 	bl	21884 <fat_file_reopen>                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   312d0:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   312d4:	03a06001 	moveq	r6, #1                                      <== NOT EXECUTED
   312d8:	01a08005 	moveq	r8, r5                                      <== NOT EXECUTED
   312dc:	0a000057 	beq	31440 <msdos_eval_path+0x1e4>                 <== NOT EXECUTED
   312e0:	ea00006b 	b	31494 <msdos_eval_path+0x238>                   <== NOT EXECUTED
        goto err;                                                     
                                                                      
    while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
    {                                                                 
        type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
   312e4:	eb000675 	bl	32cc0 <msdos_get_token>                        <== NOT EXECUTED
        pathnamelen -= token_len;                                     
   312e8:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
        i += token_len;                                               
                                                                      
        fat_fd = pathloc->node_access;                                
                                                                      
        switch (type)                                                 
   312ec:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        goto err;                                                     
                                                                      
    while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
    {                                                                 
        type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
   312f0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
        pathnamelen -= token_len;                                     
   312f4:	e062a00a 	rsb	sl, r2, sl                                    <== NOT EXECUTED
        i += token_len;                                               
   312f8:	e0888002 	add	r8, r8, r2                                    <== NOT EXECUTED
                                                                      
        fat_fd = pathloc->node_access;                                
   312fc:	e5947000 	ldr	r7, [r4]                                      <== NOT EXECUTED
                                                                      
        switch (type)                                                 
   31300:	0a000039 	beq	313ec <msdos_eval_path+0x190>                 <== NOT EXECUTED
   31304:	e3500004 	cmp	r0, #4                                        <== NOT EXECUTED
   31308:	0a000048 	beq	31430 <msdos_eval_path+0x1d4>                 <== NOT EXECUTED
   3130c:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
   31310:	1a00004a 	bne	31440 <msdos_eval_path+0x1e4>                 <== NOT EXECUTED
        {                                                             
            case MSDOS_UP_DIR:                                        
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   31314:	e5973010 	ldr	r3, [r7, #16]                                 <== NOT EXECUTED
   31318:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                           flags, pathloc);
                    }                                                 
                }                                                     
                else                                                  
                {                                                     
                  rc = msdos_find_name(pathloc, token, token_len);    
   3131c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
        {                                                             
            case MSDOS_UP_DIR:                                        
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   31320:	1a000035 	bne	313fc <msdos_eval_path+0x1a0>                 <== NOT EXECUTED
                                                                      
                /*                                                    
                 *  Am I at the root of this mounted filesystem?      
                 */                                                   
                if (pathloc->node_access ==                           
                    pathloc->mt_entry->mt_fs_root.node_access)        
   31324:	e594c010 	ldr	ip, [r4, #16]                                 <== NOT EXECUTED
                }                                                     
                                                                      
                /*                                                    
                 *  Am I at the root of this mounted filesystem?      
                 */                                                   
                if (pathloc->node_access ==                           
   31328:	e59c301c 	ldr	r3, [ip, #28]                                 <== NOT EXECUTED
   3132c:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
   31330:	1a000022 	bne	313c0 <msdos_eval_path+0x164>                 <== NOT EXECUTED
                    /*                                                
                     *  Am I at the root of all filesystems?          
                     *  XXX: MSDOS is not supposed to be base fs.     
                     */                                               
                    if (pathloc->node_access ==                       
                        rtems_filesystem_root.node_access)            
   31334:	e59f216c 	ldr	r2, [pc, #364]	; 314a8 <msdos_eval_path+0x24c><== NOT EXECUTED
   31338:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
   3133c:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
   31340:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
   31344:	0a00003d 	beq	31440 <msdos_eval_path+0x1e4>                 <== NOT EXECUTED
                    {                                                 
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
   31348:	e28cc008 	add	ip, ip, #8                                    <== NOT EXECUTED
   3134c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   31350:	e28d5008 	add	r5, sp, #8                                    <== NOT EXECUTED
   31354:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       <== NOT EXECUTED
                        *pathloc = newloc;                            
   31358:	e28de008 	add	lr, sp, #8                                    <== NOT EXECUTED
   3135c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   31360:	e1a0e004 	mov	lr, r4                                        <== NOT EXECUTED
                    {                                                 
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
   31364:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
                        *pathloc = newloc;                            
   31368:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
                                                                      
                        rc = fat_file_close(pathloc->mt_entry, fat_fd);
   3136c:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
                        *pathloc = newloc;                            
   31370:	e58ec000 	str	ip, [lr]                                      <== NOT EXECUTED
                                                                      
                        rc = fat_file_close(pathloc->mt_entry, fat_fd);
   31374:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
                    {                                                 
                        break;       /* Throw out the .. in this case */
                    }                                                 
                    else                                              
                    {                                                 
                        newloc = pathloc->mt_entry->mt_point_node;    
   31378:	e585c000 	str	ip, [r5]                                      <== NOT EXECUTED
                        *pathloc = newloc;                            
                                                                      
                        rc = fat_file_close(pathloc->mt_entry, fat_fd);
   3137c:	ebffc3cd 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
                        if (rc != RC_OK)                              
   31380:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   31384:	1a000042 	bne	31494 <msdos_eval_path+0x238>                 <== NOT EXECUTED
                            goto err;                                 
                                                                      
                        rtems_semaphore_release(fs_info->vol_sema);   
   31388:	e5990094 	ldr	r0, [r9, #148]	; 0x94                         <== NOT EXECUTED
   3138c:	ebff6991 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
                        return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
   31390:	e59d1020 	ldr	r1, [sp, #32]                                 <== NOT EXECUTED
   31394:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   31398:	e0610008 	rsb	r0, r1, r8                                    <== NOT EXECUTED
   3139c:	e0820000 	add	r0, r2, r0                                    <== NOT EXECUTED
   313a0:	e08a1001 	add	r1, sl, r1                                    <== NOT EXECUTED
   313a4:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
   313a8:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   313ac:	e594c00c 	ldr	ip, [r4, #12]                                 <== NOT EXECUTED
   313b0:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   313b4:	e59cf000 	ldr	pc, [ip]                                      <== NOT EXECUTED
   313b8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   313bc:	ea000036 	b	3149c <msdos_eval_path+0x240>                   <== NOT EXECUTED
                                                           flags, pathloc);
                    }                                                 
                }                                                     
                else                                                  
                {                                                     
                  rc = msdos_find_name(pathloc, token, token_len);    
   313c0:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
   313c4:	eb000796 	bl	33224 <msdos_find_name>                        <== NOT EXECUTED
                    if (rc != RC_OK)                                  
   313c8:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   313cc:	0a00001b 	beq	31440 <msdos_eval_path+0x1e4>                 <== NOT EXECUTED
                    {                                                 
                        if (rc == MSDOS_NAME_NOT_FOUND_ERR)           
   313d0:	e59f30d4 	ldr	r3, [pc, #212]	; 314ac <msdos_eval_path+0x250><== NOT EXECUTED
   313d4:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
   313d8:	1a000029 	bne	31484 <msdos_eval_path+0x228>                 <== NOT EXECUTED
                        {                                             
                            errno = ENOENT;                           
   313dc:	eb002ec7 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   313e0:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   313e4:	e3e0b000 	mvn	fp, #0                                        <== NOT EXECUTED
   313e8:	ea000025 	b	31484 <msdos_eval_path+0x228>                   <== NOT EXECUTED
                                                                      
            case MSDOS_NAME:                                          
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   313ec:	e5973010 	ldr	r3, [r7, #16]                                 <== NOT EXECUTED
   313f0:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                                      
                /*                                                    
                 *  Otherwise find the token name in the present location and
                 * set the node access to the point we have found.    
                 */                                                   
                rc = msdos_find_name(pathloc, token, token_len);      
   313f4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
            case MSDOS_NAME:                                          
                /*                                                    
                 *  Only a directory can be decended into.            
                 */                                                   
                if (fat_fd->fat_file_type != FAT_DIRECTORY)           
   313f8:	0a000002 	beq	31408 <msdos_eval_path+0x1ac>                 <== NOT EXECUTED
                {                                                     
                    errno = ENOTSUP;                                  
   313fc:	eb002ebf 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31400:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   31404:	ea00000b 	b	31438 <msdos_eval_path+0x1dc>                   <== NOT EXECUTED
                                                                      
                /*                                                    
                 *  Otherwise find the token name in the present location and
                 * set the node access to the point we have found.    
                 */                                                   
                rc = msdos_find_name(pathloc, token, token_len);      
   31408:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
   3140c:	eb000784 	bl	33224 <msdos_find_name>                        <== NOT EXECUTED
                if (rc != RC_OK)                                      
   31410:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   31414:	0a000009 	beq	31440 <msdos_eval_path+0x1e4>                 <== NOT EXECUTED
                {                                                     
                    if (rc == MSDOS_NAME_NOT_FOUND_ERR)               
   31418:	e59f308c 	ldr	r3, [pc, #140]	; 314ac <msdos_eval_path+0x250><== NOT EXECUTED
   3141c:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
   31420:	1a000017 	bne	31484 <msdos_eval_path+0x228>                 <== NOT EXECUTED
                    {                                                 
                        errno = ENOENT;                               
   31424:	eb002eb5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31428:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   3142c:	ea000001 	b	31438 <msdos_eval_path+0x1dc>                   <== NOT EXECUTED
            case MSDOS_NO_MORE_PATH:                                  
            case MSDOS_CURRENT_DIR:                                   
                break;                                                
                                                                      
            case MSDOS_INVALID_TOKEN:                                 
                errno = ENAMETOOLONG;                                 
   31430:	eb002eb2 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31434:	e3a0305b 	mov	r3, #91	; 0x5b                                <== NOT EXECUTED
   31438:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3143c:	eaffffe8 	b	313e4 <msdos_eval_path+0x188>                   <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        goto err;                                                     
                                                                      
    while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
    {                                                                 
        type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
   31440:	e59dc000 	ldr	ip, [sp]                                      <== NOT EXECUTED
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
    if (rc != RC_OK)                                                  
        goto err;                                                     
                                                                      
    while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
   31444:	e3560004 	cmp	r6, #4                                        <== NOT EXECUTED
   31448:	13560000 	cmpne	r6, #0                                      <== NOT EXECUTED
    {                                                                 
        type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
   3144c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   31450:	e28d201c 	add	r2, sp, #28                                   <== NOT EXECUTED
   31454:	e28d3020 	add	r3, sp, #32                                   <== NOT EXECUTED
   31458:	e08c0008 	add	r0, ip, r8                                    <== NOT EXECUTED
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
    if (rc != RC_OK)                                                  
        goto err;                                                     
                                                                      
    while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
   3145c:	1affffa0 	bne	312e4 <msdos_eval_path+0x88>                  <== NOT EXECUTED
 */                                                                   
static void                                                           
msdos_set_handlers(rtems_filesystem_location_info_t *loc)             
{                                                                     
    msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;                
    fat_file_fd_t   *fat_fd = loc->node_access;                       
   31460:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   31464:	e5932010 	ldr	r2, [r3, #16]                                 <== NOT EXECUTED
 *     None                                                           
 */                                                                   
static void                                                           
msdos_set_handlers(rtems_filesystem_location_info_t *loc)             
{                                                                     
    msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;                
   31468:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   3146c:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t   *fat_fd = loc->node_access;                       
   31470:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
                                                                      
    if (fat_fd->fat_file_type == FAT_DIRECTORY)                       
        loc->handlers = fs_info->directory_handlers;                  
   31474:	0593308c 	ldreq	r3, [r3, #140]	; 0x8c                       <== NOT EXECUTED
    else                                                              
        loc->handlers = fs_info->file_handlers;                       
   31478:	15933090 	ldrne	r3, [r3, #144]	; 0x90                       <== NOT EXECUTED
   3147c:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
   31480:	ea000003 	b	31494 <msdos_eval_path+0x238>                   <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return RC_OK;                                                     
                                                                      
error:                                                                
    fat_file_close(pathloc->mt_entry, fat_fd);                        
   31484:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31488:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   3148c:	ebffc389 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   31490:	e1a0500b 	mov	r5, fp                                        <== NOT EXECUTED
                                                                      
err:                                                                  
    rtems_semaphore_release(fs_info->vol_sema);                       
   31494:	e5990094 	ldr	r0, [r9, #148]	; 0x94                         <== NOT EXECUTED
   31498:	ebff694e 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   3149c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   314a0:	e28dd024 	add	sp, sp, #36	; 0x24                            <== NOT EXECUTED
   314a4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00031730 <msdos_file_chmod>: int msdos_file_chmod(rtems_filesystem_location_info_t *pathloc, mode_t mode) { return RC_OK; }
   31730:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   31734:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00031c1c <msdos_file_close>: int msdos_file_close(rtems_libio_t *iop) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   31c1c:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 *     RC_OK, if file closed successfully, or -1 if error occured (errno set
 *     appropriately)                                                 
 */                                                                   
int                                                                   
msdos_file_close(rtems_libio_t *iop)                                  
{                                                                     
   31c20:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31c24:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31c28:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     RC_OK, if file closed successfully, or -1 if error occured (errno set
 *     appropriately)                                                 
 */                                                                   
int                                                                   
msdos_file_close(rtems_libio_t *iop)                                  
{                                                                     
   31c2c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31c30:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   31c34:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
msdos_file_close(rtems_libio_t *iop)                                  
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   31c38:	e5946038 	ldr	r6, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31c3c:	ebff671f 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31c40:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31c44:	0a000004 	beq	31c5c <msdos_file_close+0x40>                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31c48:	eb002cac 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31c4c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31c50:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31c54:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   31c58:	ea000017 	b	31cbc <msdos_file_close+0xa0>                   <== NOT EXECUTED
                                                                      
    /*                                                                
     * if fat-file descriptor is not marked as "removed", synchronize 
     * size, first cluster number, write time and date fields of the file
     */                                                               
    if (!FAT_FILE_IS_REMOVED(fat_fd))                                 
   31c5c:	e5d63030 	ldrb	r3, [r6, #48]	; 0x30                         <== NOT EXECUTED
   31c60:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
   31c64:	1a00000e 	bne	31ca4 <msdos_file_close+0x88>                 <== NOT EXECUTED
    {                                                                 
        rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
   31c68:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31c6c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31c70:	eb00034e 	bl	329b0 <msdos_set_first_cluster_num>            <== NOT EXECUTED
        if (rc != RC_OK)                                              
   31c74:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31c78:	1a00000d 	bne	31cb4 <msdos_file_close+0x98>                 <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);     
   31c7c:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31c80:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31c84:	eb00032b 	bl	32938 <msdos_set_file_size>                    <== NOT EXECUTED
        if (rc != RC_OK)                                              
   31c88:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31c8c:	1a000008 	bne	31cb4 <msdos_file_close+0x98>                 <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
   31c90:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31c94:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31c98:	eb0003c0 	bl	32ba0 <msdos_set_dir_wrt_time_and_date>        <== NOT EXECUTED
        if (rc != RC_OK)                                              
   31c9c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31ca0:	1a000003 	bne	31cb4 <msdos_file_close+0x98>                 <== NOT EXECUTED
            rtems_semaphore_release(fs_info->vol_sema);               
            return rc;                                                
        }                                                             
    }                                                                 
                                                                      
    rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);              
   31ca4:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31ca8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31cac:	ebffc181 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   31cb0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31cb4:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31cb8:	ebff6746 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   31cbc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   31cc0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00031850 <msdos_file_datasync>: msdos_file_datasync(rtems_libio_t *iop) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; fat_file_fd_t *fat_fd = iop->file_info; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   31850:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
int                                                                   
msdos_file_datasync(rtems_libio_t *iop)                               
{                                                                     
   31854:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31858:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3185c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
int                                                                   
msdos_file_datasync(rtems_libio_t *iop)                               
{                                                                     
   31860:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31864:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   31868:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
int                                                                   
msdos_file_datasync(rtems_libio_t *iop)                               
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   3186c:	e5946038 	ldr	r6, [r4, #56]	; 0x38                          <== NOT EXECUTED
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31870:	ebff6812 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31874:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31878:	0a000004 	beq	31890 <msdos_file_datasync+0x40>              <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   3187c:	eb002d9f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31880:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31884:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31888:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   3188c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
    /* synchronize file data */                                       
    rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);           
   31890:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31894:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31898:	ebffc04c 	bl	219d0 <fat_file_datasync>                      <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   3189c:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   318a0:	ebff684c 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
   318a4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   318a8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00031968 <msdos_file_ftruncate>: * RETURNS: * RC_OK on success, or -1 if error occured (errno set appropriately). */ int msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length) {
   31968:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   3196c:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set appropriately).
 */                                                                   
int                                                                   
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)        
{                                                                     
   31970:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   31974:	e5906038 	ldr	r6, [r0, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    if (length >= fat_fd->fat_file_size)                              
   31978:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   3197c:	e1520008 	cmp	r2, r8                                        <== NOT EXECUTED
int                                                                   
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)        
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31980:	e5937034 	ldr	r7, [r3, #52]	; 0x34                          <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set appropriately).
 */                                                                   
int                                                                   
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)        
{                                                                     
   31984:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   31988:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    if (length >= fat_fd->fat_file_size)                              
   3198c:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
   31990:	ca000004 	bgt	319a8 <msdos_file_ftruncate+0x40>             <== NOT EXECUTED
   31994:	1a000001 	bne	319a0 <msdos_file_ftruncate+0x38>             <== NOT EXECUTED
   31998:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   3199c:	8a000001 	bhi	319a8 <msdos_file_ftruncate+0x40>             <== NOT EXECUTED
   319a0:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   319a4:	ea00001c 	b	31a1c <msdos_file_ftruncate+0xb4>               <== NOT EXECUTED
        return RC_OK;                                                 
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   319a8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   319ac:	e5970094 	ldr	r0, [r7, #148]	; 0x94                         <== NOT EXECUTED
   319b0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   319b4:	ebff67c1 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   319b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   319bc:	0a000004 	beq	319d4 <msdos_file_ftruncate+0x6c>             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   319c0:	eb002d4e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   319c4:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   319c8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   319cc:	e3e0a000 	mvn	sl, #0                                        <== NOT EXECUTED
   319d0:	ea000011 	b	31a1c <msdos_file_ftruncate+0xb4>               <== NOT EXECUTED
                                                                      
    rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);   
   319d4:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   319d8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   319dc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   319e0:	ebffc07b 	bl	21bd4 <fat_file_truncate>                      <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   319e4:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   319e8:	1a000009 	bne	31a14 <msdos_file_ftruncate+0xac>             <== NOT EXECUTED
                                                                      
    /*                                                                
     * fat_file_truncate do nothing if new length >= fat-file size, so update
     * file size only if length < fat-file size                       
     */                                                               
    if (length < fat_fd->fat_file_size)                               
   319ec:	e15a0008 	cmp	sl, r8                                        <== NOT EXECUTED
   319f0:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
   319f4:	ca000002 	bgt	31a04 <msdos_file_ftruncate+0x9c>             <== NOT EXECUTED
   319f8:	1a000005 	bne	31a14 <msdos_file_ftruncate+0xac>             <== NOT EXECUTED
   319fc:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
   31a00:	9a000003 	bls	31a14 <msdos_file_ftruncate+0xac>             <== NOT EXECUTED
        iop->size = fat_fd->fat_file_size = length;                   
   31a04:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   31a08:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
   31a0c:	e5865018 	str	r5, [r6, #24]                                 <== NOT EXECUTED
   31a10:	e5845004 	str	r5, [r4, #4]                                  <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31a14:	e5970094 	ldr	r0, [r7, #148]	; 0x94                         <== NOT EXECUTED
   31a18:	ebff67ee 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   31a1c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   31a20:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

00031728 <msdos_file_ioctl>: msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer) { int rc = RC_OK; return rc; }
   31728:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3172c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00031a24 <msdos_file_lseek>: * new offset on success, or -1 if error occured (errno set * appropriately). */ rtems_off64_t msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence) {
   31a24:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31a28:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
   31a2c:	e5936034 	ldr	r6, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    uint32_t           real_size = 0;                                 
   31a30:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
 *     new offset on success, or -1 if error occured (errno set       
 *     appropriately).                                                
 */                                                                   
rtems_off64_t                                                         
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{                                                                     
   31a34:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    uint32_t           real_size = 0;                                 
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31a38:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   31a3c:	e5960094 	ldr	r0, [r6, #148]	; 0x94                         <== NOT EXECUTED
   31a40:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    uint32_t           real_size = 0;                                 
   31a44:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   31a48:	e5945038 	ldr	r5, [r4, #56]	; 0x38                          <== NOT EXECUTED
    uint32_t           real_size = 0;                                 
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31a4c:	ebff679b 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31a50:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31a54:	0a000005 	beq	31a70 <msdos_file_lseek+0x4c>                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31a58:	eb002d28 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31a5c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31a60:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31a64:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   31a68:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   31a6c:	ea000019 	b	31ad8 <msdos_file_lseek+0xb4>                   <== NOT EXECUTED
                                                                      
    rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset, 
   31a70:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31a74:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   31a78:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
   31a7c:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   31a80:	ebffc091 	bl	21ccc <fat_file_extend>                        <== NOT EXECUTED
                         &real_size);                                 
    if (rc != RC_OK)                                                  
   31a84:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31a88:	0a000004 	beq	31aa0 <msdos_file_lseek+0x7c>                 <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
   31a8c:	e5960094 	ldr	r0, [r6, #148]	; 0x94                         <== NOT EXECUTED
   31a90:	ebff67d0 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
        return rc;                                                    
   31a94:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   31a98:	e1a04fc3 	asr	r4, r3, #31                                   <== NOT EXECUTED
   31a9c:	ea00000d 	b	31ad8 <msdos_file_lseek+0xb4>                   <== NOT EXECUTED
    }                                                                 
                                                                      
    if (real_size > fat_fd->fat_file_size)                            
   31aa0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   31aa4:	e5952018 	ldr	r2, [r5, #24]                                 <== NOT EXECUTED
   31aa8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
        fat_fd->fat_file_size = iop->offset = real_size;              
   31aac:	85853018 	strhi	r3, [r5, #24]                               <== NOT EXECUTED
   31ab0:	8584300c 	strhi	r3, [r4, #12]                               <== NOT EXECUTED
                                                                      
    iop->size = fat_fd->fat_file_size;                                
   31ab4:	e5953018 	ldr	r3, [r5, #24]                                 <== NOT EXECUTED
   31ab8:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
   31abc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    if (real_size > fat_fd->fat_file_size)                            
        fat_fd->fat_file_size = iop->offset = real_size;              
   31ac0:	85847010 	strhi	r7, [r4, #16]                               <== NOT EXECUTED
                                                                      
    iop->size = fat_fd->fat_file_size;                                
   31ac4:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31ac8:	e5960094 	ldr	r0, [r6, #148]	; 0x94                         <== NOT EXECUTED
   31acc:	ebff67c1 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return iop->offset;                                               
   31ad0:	e284400c 	add	r4, r4, #12                                   <== NOT EXECUTED
   31ad4:	e8940018 	ldm	r4, {r3, r4}                                  <== NOT EXECUTED
}                                                                     
   31ad8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   31adc:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   31ae0:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      <== NOT EXECUTED
                                                                      

00031cc4 <msdos_file_open>: msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   31cc4:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 *     and errno set appropriately                                    
 */                                                                   
int                                                                   
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t   flag,
                uint32_t   mode)                                      
{                                                                     
   31cc8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31ccc:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31cd0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     and errno set appropriately                                    
 */                                                                   
int                                                                   
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t   flag,
                uint32_t   mode)                                      
{                                                                     
   31cd4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31cd8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   31cdc:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
                uint32_t   mode)                                      
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   31ce0:	e5946038 	ldr	r6, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31ce4:	ebff66f5 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31ce8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31cec:	0a000004 	beq	31d04 <msdos_file_open+0x40>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31cf0:	eb002c82 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31cf4:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31cf8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31cfc:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   31d00:	ea00000e 	b	31d40 <msdos_file_open+0x7c>                    <== NOT EXECUTED
                                                                      
    rc = fat_file_reopen(fat_fd);                                     
   31d04:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   31d08:	ebffbedd 	bl	21884 <fat_file_reopen>                        <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   31d0c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31d10:	1a000008 	bne	31d38 <msdos_file_open+0x74>                  <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    if (iop->flags & LIBIO_FLAGS_APPEND)                              
   31d14:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
   31d18:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
        iop->offset = fat_fd->fat_file_size;                          
   31d1c:	15963018 	ldrne	r3, [r6, #24]                               <== NOT EXECUTED
   31d20:	1584300c 	strne	r3, [r4, #12]                               <== NOT EXECUTED
                                                                      
    iop->size = fat_fd->fat_file_size;                                
   31d24:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
   31d28:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    if (iop->flags & LIBIO_FLAGS_APPEND)                              
        iop->offset = fat_fd->fat_file_size;                          
   31d2c:	15847010 	strne	r7, [r4, #16]                               <== NOT EXECUTED
                                                                      
    iop->size = fat_fd->fat_file_size;                                
   31d30:	e5842008 	str	r2, [r4, #8]                                  <== NOT EXECUTED
   31d34:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31d38:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31d3c:	ebff6725 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   31d40:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   31d44:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00031ba8 <msdos_file_read>: ssize_t msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count) { ssize_t ret = 0; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   31ba8:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 *     the number of bytes read on success, or -1 if error occured (errno set
 *     appropriately)                                                 
 */                                                                   
ssize_t                                                               
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)       
{                                                                     
   31bac:	e92d41f1 	push	{r0, r4, r5, r6, r7, r8, lr}                 <== NOT EXECUTED
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31bb0:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
 *     the number of bytes read on success, or -1 if error occured (errno set
 *     appropriately)                                                 
 */                                                                   
ssize_t                                                               
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)       
{                                                                     
   31bb4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31bb8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     the number of bytes read on success, or -1 if error occured (errno set
 *     appropriately)                                                 
 */                                                                   
ssize_t                                                               
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)       
{                                                                     
   31bbc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   31bc0:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31bc4:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31bc8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)       
{                                                                     
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   31bcc:	e5948038 	ldr	r8, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31bd0:	ebff673a 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31bd4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31bd8:	0a000004 	beq	31bf0 <msdos_file_read+0x48>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31bdc:	eb002cc7 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31be0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31be4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31be8:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   31bec:	ea000008 	b	31c14 <msdos_file_read+0x6c>                    <== NOT EXECUTED
                                                                      
    ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
   31bf0:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
   31bf4:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31bf8:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   31bfc:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   31c00:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
   31c04:	ebffc131 	bl	220d0 <fat_file_read>                          <== NOT EXECUTED
   31c08:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                        buffer);                                      
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31c0c:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31c10:	ebff6770 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return ret;                                                       
}                                                                     
   31c14:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   31c18:	e8bd81f8 	pop	{r3, r4, r5, r6, r7, r8, pc}                  <== NOT EXECUTED
                                                                      

000317e0 <msdos_file_rmnod>: msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc, rtems_filesystem_location_info_t *pathloc) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
   317e0:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
int                                                                   
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,    
                 rtems_filesystem_location_info_t *pathloc)           
{                                                                     
   317e4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
   317e8:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
int                                                                   
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,    
                 rtems_filesystem_location_info_t *pathloc)           
{                                                                     
   317ec:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   317f0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   317f4:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   317f8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
                 rtems_filesystem_location_info_t *pathloc)           
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
    fat_file_fd_t     *fat_fd = pathloc->node_access;                 
   317fc:	e5946000 	ldr	r6, [r4]                                      <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31800:	ebff682e 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31804:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31808:	0a000004 	beq	31820 <msdos_file_rmnod+0x40>                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   3180c:	eb002dbb 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31810:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31814:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31818:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   3181c:	ea000009 	b	31848 <msdos_file_rmnod+0x68>                   <== NOT EXECUTED
                                                                      
    /* mark file removed */                                           
    rc = msdos_set_first_char4file_name(pathloc->mt_entry,            
   31820:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31824:	e2861020 	add	r1, r6, #32                                   <== NOT EXECUTED
   31828:	e3a020e5 	mov	r2, #229	; 0xe5                               <== NOT EXECUTED
   3182c:	eb00048c 	bl	32a64 <msdos_set_first_char4file_name>         <== NOT EXECUTED
                                        &fat_fd->dir_pos,             
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
    if (rc != RC_OK)                                                  
   31830:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    fat_file_mark_removed(pathloc->mt_entry, fat_fd);                 
   31834:	05940010 	ldreq	r0, [r4, #16]                               <== NOT EXECUTED
   31838:	01a01006 	moveq	r1, r6                                      <== NOT EXECUTED
   3183c:	0bffc0a3 	bleq	21ad0 <fat_file_mark_removed>                <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31840:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31844:	ebff6863 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   31848:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   3184c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00031738 <msdos_file_stat>: rtems_filesystem_location_info_t *loc, struct stat *buf ) { rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
   31738:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
int                                                                   
msdos_file_stat(                                                      
    rtems_filesystem_location_info_t *loc,                            
    struct stat                      *buf                             
    )                                                                 
{                                                                     
   3173c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
   31740:	e5925034 	ldr	r5, [r2, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
msdos_file_stat(                                                      
    rtems_filesystem_location_info_t *loc,                            
    struct stat                      *buf                             
    )                                                                 
{                                                                     
   31744:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
    fat_file_fd_t     *fat_fd = loc->node_access;                     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31748:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
int                                                                   
msdos_file_stat(                                                      
    rtems_filesystem_location_info_t *loc,                            
    struct stat                      *buf                             
    )                                                                 
{                                                                     
   3174c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
    fat_file_fd_t     *fat_fd = loc->node_access;                     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31750:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   31754:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
    struct stat                      *buf                             
    )                                                                 
{                                                                     
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = loc->mt_entry->fs_info;              
    fat_file_fd_t     *fat_fd = loc->node_access;                     
   31758:	e5936000 	ldr	r6, [r3]                                      <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   3175c:	ebff6857 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31760:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31764:	0a000004 	beq	3177c <msdos_file_stat+0x44>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31768:	eb002de4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3176c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31770:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31774:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   31778:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
    buf->st_dev = fs_info->fat.vol.dev;                               
    buf->st_ino = fat_fd->ino;                                        
   3177c:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   31780:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
   31784:	e59f3050 	ldr	r3, [pc, #80]	; 317dc <msdos_file_stat+0xa4>  <== NOT EXECUTED
   31788:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
   3178c:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
    buf->st_blksize = fs_info->fat.vol.bps;                           
   31790:	e1d520b0 	ldrh	r2, [r5]                                     <== NOT EXECUTED
    buf->st_dev = fs_info->fat.vol.dev;                               
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
   31794:	e1a014a3 	lsr	r1, r3, #9                                    <== NOT EXECUTED
   31798:	e5841044 	str	r1, [r4, #68]	; 0x44                          <== NOT EXECUTED
    buf->st_blksize = fs_info->fat.vol.bps;                           
   3179c:	e5842040 	str	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
    buf->st_mtime = fat_fd->mtime;                                    
   317a0:	e5962040 	ldr	r2, [r6, #64]	; 0x40                          <== NOT EXECUTED
   317a4:	e5842030 	str	r2, [r4, #48]	; 0x30                          <== NOT EXECUTED
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    buf->st_dev = fs_info->fat.vol.dev;                               
   317a8:	e2852054 	add	r2, r5, #84	; 0x54                            <== NOT EXECUTED
   317ac:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
   317b0:	e8840006 	stm	r4, {r1, r2}                                  <== NOT EXECUTED
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
   317b4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   317b8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   317bc:	e5841018 	str	r1, [r4, #24]                                 <== NOT EXECUTED
   317c0:	e584201c 	str	r2, [r4, #28]                                 <== NOT EXECUTED
    buf->st_size = fat_fd->fat_file_size;                             
   317c4:	e5843020 	str	r3, [r4, #32]                                 <== NOT EXECUTED
   317c8:	e5847024 	str	r7, [r4, #36]	; 0x24                          <== NOT EXECUTED
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
    buf->st_blksize = fs_info->fat.vol.bps;                           
    buf->st_mtime = fat_fd->mtime;                                    
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   317cc:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   317d0:	ebff6880 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
   317d4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   317d8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000318ac <msdos_file_sync>: msdos_file_sync(rtems_libio_t *iop) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; fat_file_fd_t *fat_fd = iop->file_info; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   318ac:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
int                                                                   
msdos_file_sync(rtems_libio_t *iop)                                   
{                                                                     
   318b0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   318b4:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   318b8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 * RETURNS:                                                           
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
int                                                                   
msdos_file_sync(rtems_libio_t *iop)                                   
{                                                                     
   318bc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   318c0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   318c4:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
int                                                                   
msdos_file_sync(rtems_libio_t *iop)                                   
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   318c8:	e5956038 	ldr	r6, [r5, #56]	; 0x38                          <== NOT EXECUTED
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   318cc:	ebff67fb 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   318d0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   318d4:	0a000004 	beq	318ec <msdos_file_sync+0x40>                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   318d8:	eb002d88 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   318dc:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   318e0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   318e4:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   318e8:	ea00001c 	b	31960 <msdos_file_sync+0xb4>                    <== NOT EXECUTED
                                                                      
    /* synchronize file data */                                       
    rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);           
   318ec:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
   318f0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   318f4:	ebffc035 	bl	219d0 <fat_file_datasync>                      <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   318f8:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   318fc:	1a000011 	bne	31948 <msdos_file_sync+0x9c>                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * if fat-file descriptor is not marked "removed" - synchronize file
     * metadata                                                       
     */                                                               
    if (!FAT_FILE_IS_REMOVED(fat_fd))                                 
   31900:	e5d63030 	ldrb	r3, [r6, #48]	; 0x30                         <== NOT EXECUTED
   31904:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
   31908:	1a000011 	bne	31954 <msdos_file_sync+0xa8>                  <== NOT EXECUTED
    {                                                                 
        rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
   3190c:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
   31910:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31914:	eb000425 	bl	329b0 <msdos_set_first_cluster_num>            <== NOT EXECUTED
        if (rc != RC_OK)                                              
   31918:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   3191c:	1a000009 	bne	31948 <msdos_file_sync+0x9c>                  <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
            return rc;                                                
        }                                                             
        rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);     
   31920:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
   31924:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   31928:	eb000402 	bl	32938 <msdos_set_file_size>                    <== NOT EXECUTED
        if (rc != RC_OK)                                              
   3192c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31930:	1a000004 	bne	31948 <msdos_file_sync+0x9c>                  <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
            return rc;                                                
        }                                                             
        rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
   31934:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
   31938:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3193c:	eb000497 	bl	32ba0 <msdos_set_dir_wrt_time_and_date>        <== NOT EXECUTED
        if (rc != RC_OK)                                              
   31940:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31944:	0a000002 	beq	31954 <msdos_file_sync+0xa8>                  <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
   31948:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   3194c:	ebff6821 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
            return rc;                                                
   31950:	ea000002 	b	31960 <msdos_file_sync+0xb4>                    <== NOT EXECUTED
        }                                                             
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31954:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   31958:	ebff681e 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
   3195c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
   31960:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   31964:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00031ae4 <msdos_file_write>: ssize_t msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count) { ssize_t ret = 0; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
   31ae4:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 *     the number of bytes written on success, or -1 if error occured 
 *     and errno set appropriately                                    
 */                                                                   
ssize_t                                                               
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count) 
{                                                                     
   31ae8:	e92d41f1 	push	{r0, r4, r5, r6, r7, r8, lr}                 <== NOT EXECUTED
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
   31aec:	e5936034 	ldr	r6, [r3, #52]	; 0x34                          <== NOT EXECUTED
 *     the number of bytes written on success, or -1 if error occured 
 *     and errno set appropriately                                    
 */                                                                   
ssize_t                                                               
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count) 
{                                                                     
   31af0:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31af4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     the number of bytes written on success, or -1 if error occured 
 *     and errno set appropriately                                    
 */                                                                   
ssize_t                                                               
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count) 
{                                                                     
   31af8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   31afc:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31b00:	e5960094 	ldr	r0, [r6, #148]	; 0x94                         <== NOT EXECUTED
   31b04:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count) 
{                                                                     
    ssize_t            ret = 0;                                       
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = iop->pathinfo.mt_entry->fs_info;     
    fat_file_fd_t     *fat_fd = iop->file_info;                       
   31b08:	e5945038 	ldr	r5, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31b0c:	ebff676b 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31b10:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31b14:	0a000003 	beq	31b28 <msdos_file_write+0x44>                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31b18:	eb002cf8 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31b1c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31b20:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31b24:	ea000009 	b	31b50 <msdos_file_write+0x6c>                   <== NOT EXECUTED
                                                                      
    ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
   31b28:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
   31b2c:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
   31b30:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   31b34:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   31b38:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
   31b3c:	ebffc0d6 	bl	21e9c <fat_file_write>                         <== NOT EXECUTED
                         buffer);                                     
    if (ret < 0)                                                      
   31b40:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   31b44:	aa000003 	bge	31b58 <msdos_file_write+0x74>                 <== NOT EXECUTED
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
   31b48:	e5960094 	ldr	r0, [r6, #148]	; 0x94                         <== NOT EXECUTED
   31b4c:	ebff67a1 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
   31b50:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
        return -1;                                                    
   31b54:	ea000011 	b	31ba0 <msdos_file_write+0xbc>                   <== NOT EXECUTED
                                                                      
    /*                                                                
     * update file size in both fat-file descriptor and file control block if
     * file was extended                                              
     */                                                               
    if (iop->offset + ret > fat_fd->fat_file_size)                    
   31b58:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
   31b5c:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
   31b60:	e0920007 	adds	r0, r2, r7                                   <== NOT EXECUTED
   31b64:	e0a31fc7 	adc	r1, r3, r7, asr #31                           <== NOT EXECUTED
   31b68:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   31b6c:	e595c018 	ldr	ip, [r5, #24]                                 <== NOT EXECUTED
   31b70:	ca000002 	bgt	31b80 <msdos_file_write+0x9c>                 <== NOT EXECUTED
   31b74:	1a000003 	bne	31b88 <msdos_file_write+0xa4>                 <== NOT EXECUTED
   31b78:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
   31b7c:	9a000001 	bls	31b88 <msdos_file_write+0xa4>                 <== NOT EXECUTED
        fat_fd->fat_file_size = iop->offset + ret;                    
   31b80:	e0872002 	add	r2, r7, r2                                    <== NOT EXECUTED
   31b84:	e5852018 	str	r2, [r5, #24]                                 <== NOT EXECUTED
                                                                      
    iop->size = fat_fd->fat_file_size;                                
   31b88:	e5953018 	ldr	r3, [r5, #24]                                 <== NOT EXECUTED
   31b8c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   31b90:	e5842008 	str	r2, [r4, #8]                                  <== NOT EXECUTED
   31b94:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31b98:	e5960094 	ldr	r0, [r6, #148]	; 0x94                         <== NOT EXECUTED
   31b9c:	ebff678d 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return ret;                                                       
}                                                                     
   31ba0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   31ba4:	e8bd81f8 	pop	{r3, r4, r5, r6, r7, r8, pc}                  <== NOT EXECUTED
                                                                      

0003b938 <msdos_filename_unix2dos>: * Convert a unix filename to a DOS filename. Return -1 if wrong name is * supplied. */ int msdos_filename_unix2dos(const char *un, int unlen, char *dn) {
   3b938:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   3b93c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
	/*                                                                   
	 * Fill the dos filename string with blanks. These are DOS's pad     
	 * characters.                                                       
	 */                                                                  
	for (i = 0; i <= 10; i++)                                            
		dn[i] = ' ';                                                        
   3b940:	e3a0c020 	mov	ip, #32                                       <== NOT EXECUTED
   3b944:	e7c2c003 	strb	ip, [r2, r3]                                 <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * Fill the dos filename string with blanks. These are DOS's pad     
	 * characters.                                                       
	 */                                                                  
	for (i = 0; i <= 10; i++)                                            
   3b948:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3b94c:	e353000b 	cmp	r3, #11                                       <== NOT EXECUTED
   3b950:	1afffffb 	bne	3b944 <msdos_filename_unix2dos+0xc>           <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * The filenames "." and ".." are handled specially, since they      
	 * don't follow dos filename rules.                                  
	 */                                                                  
	if (un[0] == '.' && unlen == 1) {                                    
   3b954:	e5d03000 	ldrb	r3, [r0]                                     <== NOT EXECUTED
   3b958:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   3b95c:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
   3b960:	03a0c001 	moveq	ip, #1                                      <== NOT EXECUTED
   3b964:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
   3b968:	0353002e 	cmpeq	r3, #46	; 0x2e                              <== NOT EXECUTED
		dn[0] = '.';                                                        
   3b96c:	03a0302e 	moveq	r3, #46	; 0x2e                              <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * The filenames "." and ".." are handled specially, since they      
	 * don't follow dos filename rules.                                  
	 */                                                                  
	if (un[0] == '.' && unlen == 1) {                                    
   3b970:	0a000007 	beq	3b994 <msdos_filename_unix2dos+0x5c>          <== NOT EXECUTED
		dn[0] = '.';                                                        
		return 0;                                                           
	}                                                                    
	if (un[0] == '.' && un[1] == '.' && unlen == 2) {                    
   3b974:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   3b978:	0a000009 	beq	3b9a4 <msdos_filename_unix2dos+0x6c>          <== NOT EXECUTED
   3b97c:	e5d03001 	ldrb	r3, [r0, #1]                                 <== NOT EXECUTED
   3b980:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   3b984:	03510002 	cmpeq	r1, #2                                      <== NOT EXECUTED
   3b988:	1a000005 	bne	3b9a4 <msdos_filename_unix2dos+0x6c>          <== NOT EXECUTED
		dn[0] = '.';                                                        
   3b98c:	e3a0302e 	mov	r3, #46	; 0x2e                                <== NOT EXECUTED
		dn[1] = '.';                                                        
   3b990:	e5c23001 	strb	r3, [r2, #1]                                 <== NOT EXECUTED
	if (un[0] == '.' && unlen == 1) {                                    
		dn[0] = '.';                                                        
		return 0;                                                           
	}                                                                    
	if (un[0] == '.' && un[1] == '.' && unlen == 2) {                    
		dn[0] = '.';                                                        
   3b994:	e5c23000 	strb	r3, [r2]                                     <== NOT EXECUTED
		dn[1] = '.';                                                        
		return 0;                                                           
   3b998:	ea00003a 	b	3ba88 <msdos_filename_unix2dos+0x150>           <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
		un++;                                                               
   3b99c:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
		unlen--;                                                            
   3b9a0:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
   3b9a4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   3b9a8:	1a000002 	bne	3b9b8 <msdos_filename_unix2dos+0x80>          <== NOT EXECUTED
   3b9ac:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
	 * of string, a '.', or 8 characters. Whichever happens first stops  
	 * us. This forms the name portion of the dos filename. Fold to      
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
    if (msdos_map[c] == 0)                                            
   3b9b0:	e59f50d8 	ldr	r5, [pc, #216]	; 3ba90 <msdos_filename_unix2dos+0x158><== NOT EXECUTED
   3b9b4:	ea000009 	b	3b9e0 <msdos_filename_unix2dos+0xa8>            <== NOT EXECUTED
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
   3b9b8:	e5d03000 	ldrb	r3, [r0]                                     <== NOT EXECUTED
   3b9bc:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   3b9c0:	0afffff5 	beq	3b99c <msdos_filename_unix2dos+0x64>          <== NOT EXECUTED
   3b9c4:	eafffff8 	b	3b9ac <msdos_filename_unix2dos+0x74>            <== NOT EXECUTED
	 * of string, a '.', or 8 characters. Whichever happens first stops  
	 * us. This forms the name portion of the dos filename. Fold to      
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
    if (msdos_map[c] == 0)                                            
   3b9c8:	e7d54004 	ldrb	r4, [r5, r4]                                 <== NOT EXECUTED
   3b9cc:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3b9d0:	0a000013 	beq	3ba24 <msdos_filename_unix2dos+0xec>          <== NOT EXECUTED
      break;                                                          
		dn[i] = msdos_map[c];                                               
   3b9d4:	e7c24003 	strb	r4, [r2, r3]                                 <== NOT EXECUTED
		un++;                                                               
		unlen--;                                                            
   3b9d8:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
	 * Copy the unix filename into the dos filename string upto the end  
	 * of string, a '.', or 8 characters. Whichever happens first stops  
	 * us. This forms the name portion of the dos filename. Fold to      
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
   3b9dc:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3b9e0:	e251c000 	subs	ip, r1, #0                                   <== NOT EXECUTED
   3b9e4:	13a0c001 	movne	ip, #1                                      <== NOT EXECUTED
   3b9e8:	e3530007 	cmp	r3, #7                                        <== NOT EXECUTED
   3b9ec:	c3a0c000 	movgt	ip, #0                                      <== NOT EXECUTED
   3b9f0:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
/*                                                                    
 * Convert a unix filename to a DOS filename. Return -1 if wrong name is
 * supplied.                                                          
 */                                                                   
int                                                                   
msdos_filename_unix2dos(const char *un, int unlen, char *dn)          
   3b9f4:	e080c003 	add	ip, r0, r3                                    <== NOT EXECUTED
	 * Copy the unix filename into the dos filename string upto the end  
	 * of string, a '.', or 8 characters. Whichever happens first stops  
	 * us. This forms the name portion of the dos filename. Fold to      
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
   3b9f8:	0a000009 	beq	3ba24 <msdos_filename_unix2dos+0xec>          <== NOT EXECUTED
   3b9fc:	e7d04003 	ldrb	r4, [r0, r3]                                 <== NOT EXECUTED
   3ba00:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3ba04:	0a000006 	beq	3ba24 <msdos_filename_unix2dos+0xec>          <== NOT EXECUTED
   3ba08:	e354002e 	cmp	r4, #46	; 0x2e                                <== NOT EXECUTED
   3ba0c:	1affffed 	bne	3b9c8 <msdos_filename_unix2dos+0x90>          <== NOT EXECUTED
   3ba10:	ea000003 	b	3ba24 <msdos_filename_unix2dos+0xec>            <== NOT EXECUTED
	 */                                                                  
	while (unlen && (c = *un)) {                                         
		un++;                                                               
		unlen--;                                                            
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
   3ba14:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
		un++;                                                               
   3ba18:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
		unlen--;                                                            
   3ba1c:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
   3ba20:	0a000004 	beq	3ba38 <msdos_filename_unix2dos+0x100>         <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
   3ba24:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   3ba28:	0a000002 	beq	3ba38 <msdos_filename_unix2dos+0x100>         <== NOT EXECUTED
   3ba2c:	e5dc3000 	ldrb	r3, [ip]                                     <== NOT EXECUTED
   3ba30:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3ba34:	1afffff6 	bne	3ba14 <msdos_filename_unix2dos+0xdc>          <== NOT EXECUTED
   3ba38:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3ba3c:	e3a03008 	mov	r3, #8                                        <== NOT EXECUTED
	 * Copy in the extension part of the name, if any. Force to upper    
	 * case. Note that the extension is allowed to contain '.'s.         
	 * Filenames in this form are probably inaccessable under dos.       
	 */                                                                  
	for (i = 8; i <= 10 && unlen && (c = *un); i++) {                    
    if (msdos_map[c] == 0)                                            
   3ba40:	e59f5048 	ldr	r5, [pc, #72]	; 3ba90 <msdos_filename_unix2dos+0x158><== NOT EXECUTED
   3ba44:	ea000006 	b	3ba64 <msdos_filename_unix2dos+0x12c>           <== NOT EXECUTED
   3ba48:	e7d54004 	ldrb	r4, [r5, r4]                                 <== NOT EXECUTED
   3ba4c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3ba50:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
   3ba54:	0a00000b 	beq	3ba88 <msdos_filename_unix2dos+0x150>         <== NOT EXECUTED
      break;                                                          
    dn[i] = msdos_map[c];                                             
   3ba58:	e7c24003 	strb	r4, [r2, r3]                                 <== NOT EXECUTED
		un++;                                                               
		unlen--;                                                            
   3ba5c:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
	/*                                                                   
	 * Copy in the extension part of the name, if any. Force to upper    
	 * case. Note that the extension is allowed to contain '.'s.         
	 * Filenames in this form are probably inaccessable under dos.       
	 */                                                                  
	for (i = 8; i <= 10 && unlen && (c = *un); i++) {                    
   3ba60:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3ba64:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
   3ba68:	13a04001 	movne	r4, #1                                      <== NOT EXECUTED
   3ba6c:	e353000a 	cmp	r3, #10                                       <== NOT EXECUTED
   3ba70:	c3a04000 	movgt	r4, #0                                      <== NOT EXECUTED
   3ba74:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3ba78:	0a000002 	beq	3ba88 <msdos_filename_unix2dos+0x150>         <== NOT EXECUTED
   3ba7c:	e7dc4000 	ldrb	r4, [ip, r0]                                 <== NOT EXECUTED
   3ba80:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3ba84:	1affffef 	bne	3ba48 <msdos_filename_unix2dos+0x110>         <== NOT EXECUTED
    dn[i] = msdos_map[c];                                             
		un++;                                                               
		unlen--;                                                            
	}                                                                    
	return 0;                                                            
}                                                                     
   3ba88:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3ba8c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00033224 <msdos_find_name>: msdos_find_name( rtems_filesystem_location_info_t *parent_loc, const char *name, int name_len ) {
   33224:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
   33228:	e24dd040 	sub	sp, sp, #64	; 0x40                            <== NOT EXECUTED
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
    fat_file_fd_t     *fat_fd = NULL;                                 
   3322c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
   33230:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
    fat_dir_pos_t      dir_pos;                                       
    unsigned short     time_val = 0;                                  
    unsigned short     date = 0;                                      
    char               node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE]; 
                                                                      
    memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   33234:	e28d500c 	add	r5, sp, #12                                   <== NOT EXECUTED
msdos_find_name(                                                      
    rtems_filesystem_location_info_t *parent_loc,                     
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
   33238:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
   3323c:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
    fat_dir_pos_t      dir_pos;                                       
    unsigned short     time_val = 0;                                  
    unsigned short     date = 0;                                      
    char               node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE]; 
                                                                      
    memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   33240:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
msdos_find_name(                                                      
    rtems_filesystem_location_info_t *parent_loc,                     
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
   33244:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    fat_dir_pos_t      dir_pos;                                       
    unsigned short     time_val = 0;                                  
    unsigned short     date = 0;                                      
    char               node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE]; 
                                                                      
    memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   33248:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   3324c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
   33250:	e593a034 	ldr	sl, [r3, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t     *fat_fd = NULL;                                 
   33254:	e58d603c 	str	r6, [sp, #60]	; 0x3c                          <== NOT EXECUTED
    fat_dir_pos_t      dir_pos;                                       
    unsigned short     time_val = 0;                                  
    unsigned short     date = 0;                                      
    char               node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE]; 
                                                                      
    memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
   33258:	eb00345f 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    name_type = msdos_long_to_short (name,                            
   3325c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   33260:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   33264:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   33268:	e3a0300b 	mov	r3, #11                                       <== NOT EXECUTED
   3326c:	ebfffecb 	bl	32da0 <msdos_long_to_short>                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * find the node which correspondes to the name in the directory pointed by
     * 'parent_loc'                                                   
     */                                                               
    rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
   33270:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   33274:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   33278:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   3327c:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   33280:	e28d602c 	add	r6, sp, #44	; 0x2c                            <== NOT EXECUTED
   33284:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   33288:	e58d6004 	str	r6, [sp, #4]                                  <== NOT EXECUTED
   3328c:	e58d5008 	str	r5, [sp, #8]                                  <== NOT EXECUTED
   33290:	ebffffac 	bl	33148 <msdos_get_name_node>                    <== NOT EXECUTED
                             &dir_pos, node_entry);                   
    if (rc != RC_OK)                                                  
   33294:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   33298:	1a000045 	bne	333b4 <msdos_find_name+0x190>                 <== NOT EXECUTED
        return rc;                                                    
                                                                      
    if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||     
   3329c:	e5dd3017 	ldrb	r3, [sp, #23]                                <== NOT EXECUTED
   332a0:	e3130008 	tst	r3, #8                                        <== NOT EXECUTED
   332a4:	1a000041 	bne	333b0 <msdos_find_name+0x18c>                 <== NOT EXECUTED
   332a8:	e203303f 	and	r3, r3, #63	; 0x3f                            <== NOT EXECUTED
   332ac:	e353000f 	cmp	r3, #15                                       <== NOT EXECUTED
   332b0:	0a00003e 	beq	333b0 <msdos_find_name+0x18c>                 <== NOT EXECUTED
        ((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
        return MSDOS_NAME_NOT_FOUND_ERR;                              
                                                                      
    /* open fat-file corresponded to the found node */                
    rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);      
   332b4:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   332b8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   332bc:	e28d203c 	add	r2, sp, #60	; 0x3c                            <== NOT EXECUTED
   332c0:	ebffbc25 	bl	2235c <fat_file_open>                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   332c4:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   332c8:	1a000039 	bne	333b4 <msdos_find_name+0x190>                 <== NOT EXECUTED
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
   332cc:	e59d703c 	ldr	r7, [sp, #60]	; 0x3c                          <== NOT EXECUTED
     * size and first cluster num to the disk after each write operation
     * (even if one byte is written  - that is TOO slow) because      
     * otherwise real values of these fields stored in fat-file descriptor
     * may be accidentally rewritten with wrong values stored on the disk
     */                                                               
    if (fat_fd->links_num == 1)                                       
   332d0:	e5978008 	ldr	r8, [r7, #8]                                  <== NOT EXECUTED
    /* open fat-file corresponded to the found node */                
    rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);      
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
   332d4:	e896000f 	ldm	r6, {r0, r1, r2, r3}                          <== NOT EXECUTED
   332d8:	e287c020 	add	ip, r7, #32                                   <== NOT EXECUTED
     * size and first cluster num to the disk after each write operation
     * (even if one byte is written  - that is TOO slow) because      
     * otherwise real values of these fields stored in fat-file descriptor
     * may be accidentally rewritten with wrong values stored on the disk
     */                                                               
    if (fat_fd->links_num == 1)                                       
   332dc:	e3580001 	cmp	r8, #1                                        <== NOT EXECUTED
    /* open fat-file corresponded to the found node */                
    rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);      
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
   332e0:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          <== NOT EXECUTED
     * size and first cluster num to the disk after each write operation
     * (even if one byte is written  - that is TOO slow) because      
     * otherwise real values of these fields stored in fat-file descriptor
     * may be accidentally rewritten with wrong values stored on the disk
     */                                                               
    if (fat_fd->links_num == 1)                                       
   332e4:	1a000026 	bne	33384 <msdos_find_name+0x160>                 <== NOT EXECUTED
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
   332e8:	e1d521b4 	ldrh	r2, [r5, #20]                                <== NOT EXECUTED
   332ec:	e1d531ba 	ldrh	r3, [r5, #26]                                <== NOT EXECUTED
   332f0:	e1833802 	orr	r3, r3, r2, lsl #16                           <== NOT EXECUTED
   332f4:	e587301c 	str	r3, [r7, #28]                                 <== NOT EXECUTED
                                                                      
        time_val = *MSDOS_DIR_WRITE_TIME(node_entry);                 
        date = *MSDOS_DIR_WRITE_DATE(node_entry);                     
                                                                      
        fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
   332f8:	e1d511b6 	ldrh	r1, [r5, #22]                                <== NOT EXECUTED
   332fc:	e1d501b8 	ldrh	r0, [r5, #24]                                <== NOT EXECUTED
   33300:	eb00214a 	bl	3b830 <msdos_date_dos2unix>                    <== NOT EXECUTED
   33304:	e5870040 	str	r0, [r7, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
        if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)     
   33308:	e5dd3017 	ldrb	r3, [sp, #23]                                <== NOT EXECUTED
   3330c:	e3130010 	tst	r3, #16                                       <== NOT EXECUTED
   33310:	e59d103c 	ldr	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   33314:	0a000007 	beq	33338 <msdos_find_name+0x114>                 <== NOT EXECUTED
        {                                                             
            fat_fd->fat_file_type = FAT_DIRECTORY;                    
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
   33318:	e3a03602 	mov	r3, #2097152	; 0x200000                       <== NOT EXECUTED
                                                                      
        fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
                                                                      
        if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)     
        {                                                             
            fat_fd->fat_file_type = FAT_DIRECTORY;                    
   3331c:	e5818010 	str	r8, [r1, #16]                                 <== NOT EXECUTED
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
   33320:	e5813014 	str	r3, [r1, #20]                                 <== NOT EXECUTED
                                                                      
            rc = fat_file_size(parent_loc->mt_entry, fat_fd);         
   33324:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   33328:	ebffb95a 	bl	21898 <fat_file_size>                          <== NOT EXECUTED
            if (rc != RC_OK)                                          
   3332c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   33330:	0a000006 	beq	33350 <msdos_find_name+0x12c>                 <== NOT EXECUTED
   33334:	ea000019 	b	333a0 <msdos_find_name+0x17c>                   <== NOT EXECUTED
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
   33338:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
            fat_fd->fat_file_type = FAT_FILE;                         
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
   3333c:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
   33340:	e5813018 	str	r3, [r1, #24]                                 <== NOT EXECUTED
            fat_fd->fat_file_type = FAT_FILE;                         
   33344:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
   33348:	e5812014 	str	r2, [r1, #20]                                 <== NOT EXECUTED
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
            fat_fd->fat_file_type = FAT_FILE;                         
   3334c:	e5813010 	str	r3, [r1, #16]                                 <== NOT EXECUTED
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
        }                                                             
                                                                      
        /* these data is not actual for zero-length fat-file */       
        fat_fd->map.file_cln = 0;                                     
   33350:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
        fat_fd->map.disk_cln = fat_fd->cln;                           
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
   33354:	e2831018 	add	r1, r3, #24                                   <== NOT EXECUTED
   33358:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
            fat_fd->fat_file_type = FAT_FILE;                         
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
        }                                                             
                                                                      
        /* these data is not actual for zero-length fat-file */       
        fat_fd->map.file_cln = 0;                                     
   3335c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
        fat_fd->map.disk_cln = fat_fd->cln;                           
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
   33360:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
            fat_fd->fat_file_type = FAT_FILE;                         
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
        }                                                             
                                                                      
        /* these data is not actual for zero-length fat-file */       
        fat_fd->map.file_cln = 0;                                     
   33364:	e5830034 	str	r0, [r3, #52]	; 0x34                          <== NOT EXECUTED
        fat_fd->map.disk_cln = fat_fd->cln;                           
   33368:	e5832038 	str	r2, [r3, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
   3336c:	0a000002 	beq	3337c <msdos_find_name+0x158>                 <== NOT EXECUTED
            (fat_fd->fat_file_size <= fs_info->fat.vol.bpc))          
   33370:	e1da00b6 	ldrh	r0, [sl, #6]                                 <== NOT EXECUTED
   33374:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
   33378:	9a000000 	bls	33380 <msdos_find_name+0x15c>                 <== NOT EXECUTED
        {                                                             
            fat_fd->map.last_cln = fat_fd->cln;                       
        }                                                             
        else                                                          
        {                                                             
            fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;               
   3337c:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
   33380:	e583203c 	str	r2, [r3, #60]	; 0x3c                          <== NOT EXECUTED
        }                                                             
    }                                                                 
                                                                      
    /* close fat-file corresponded to the node we searched in */      
    rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
   33384:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   33388:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
   3338c:	ebffbbc9 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   33390:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
        fat_file_close(parent_loc->mt_entry, fat_fd);                 
        return rc;                                                    
    }                                                                 
                                                                      
    /* update node_info_ptr field */                                  
    parent_loc->node_access = fat_fd;                                 
   33394:	059d303c 	ldreq	r3, [sp, #60]	; 0x3c                        <== NOT EXECUTED
   33398:	05843000 	streq	r3, [r4]                                    <== NOT EXECUTED
        }                                                             
    }                                                                 
                                                                      
    /* close fat-file corresponded to the node we searched in */      
    rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
    if (rc != RC_OK)                                                  
   3339c:	0a000004 	beq	333b4 <msdos_find_name+0x190>                 <== NOT EXECUTED
    {                                                                 
        fat_file_close(parent_loc->mt_entry, fat_fd);                 
   333a0:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   333a4:	e59d103c 	ldr	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   333a8:	ebffbbc2 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
        return rc;                                                    
   333ac:	ea000000 	b	333b4 <msdos_find_name+0x190>                   <== NOT EXECUTED
    }                                                                 
                                                                      
    /* update node_info_ptr field */                                  
    parent_loc->node_access = fat_fd;                                 
                                                                      
    return rc;                                                        
   333b0:	e59f7008 	ldr	r7, [pc, #8]	; 333c0 <msdos_find_name+0x19c>  <== NOT EXECUTED
}                                                                     
   333b4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   333b8:	e28dd040 	add	sp, sp, #64	; 0x40                            <== NOT EXECUTED
   333bc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

00031f4c <msdos_find_name_in_fat_file>: int name_len, msdos_name_type_t name_type, fat_dir_pos_t *dir_pos, char *name_dir_entry ) {
   31f4c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   31f50:	e24dd050 	sub	sp, sp, #80	; 0x50                            <== NOT EXECUTED
   31f54:	e58d001c 	str	r0, [sp, #28]                                 <== NOT EXECUTED
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
                                                                      
    assert(name_len > 0);                                             
   31f58:	e59d0074 	ldr	r0, [sp, #116]	; 0x74                         <== NOT EXECUTED
    int                                   name_len,                   
    msdos_name_type_t                     name_type,                  
    fat_dir_pos_t                        *dir_pos,                    
    char                                 *name_dir_entry              
                                )                                     
{                                                                     
   31f5c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   31f60:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
    int                                   name_len,                   
    msdos_name_type_t                     name_type,                  
    fat_dir_pos_t                        *dir_pos,                    
    char                                 *name_dir_entry              
                                )                                     
{                                                                     
   31f64:	e20220ff 	and	r2, r2, #255	; 0xff                           <== NOT EXECUTED
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
                                                                      
    assert(name_len > 0);                                             
   31f68:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    int                                   name_len,                   
    msdos_name_type_t                     name_type,                  
    fat_dir_pos_t                        *dir_pos,                    
    char                                 *name_dir_entry              
                                )                                     
{                                                                     
   31f6c:	e58d3038 	str	r3, [sp, #56]	; 0x38                          <== NOT EXECUTED
   31f70:	e58d2024 	str	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
   31f74:	e59d807c 	ldr	r8, [sp, #124]	; 0x7c                         <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   31f78:	e5917034 	ldr	r7, [r1, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
                                                                      
    assert(name_len > 0);                                             
   31f7c:	d59f0874 	ldrle	r0, [pc, #2164]	; 327f8 <msdos_find_name_in_fat_file+0x8ac><== NOT EXECUTED
   31f80:	d59f1874 	ldrle	r1, [pc, #2164]	; 327fc <msdos_find_name_in_fat_file+0x8b0><== NOT EXECUTED
   31f84:	d59f2874 	ldrle	r2, [pc, #2164]	; 32800 <msdos_find_name_in_fat_file+0x8b4><== NOT EXECUTED
   31f88:	d59f3874 	ldrle	r3, [pc, #2164]	; 32804 <msdos_find_name_in_fat_file+0x8b8><== NOT EXECUTED
   31f8c:	da000034 	ble	32064 <msdos_find_name_in_fat_file+0x118>     <== NOT EXECUTED
     * is short still check for possible long entries with the short name.
     *                                                                
     * In PR1491 we need to have a LFN for a short file name entry. To
     * test this make this test always fail, ie add "0 &&".           
     */                                                               
    if (create_node && (name_type == MSDOS_NAME_SHORT))               
   31f90:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
static inline void                                                    
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
   31f94:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   31f98:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   31f9c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
   31fa0:	e588300c 	str	r3, [r8, #12]                                 <== NOT EXECUTED
static inline void                                                    
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
   31fa4:	e588a000 	str	sl, [r8]                                      <== NOT EXECUTED
  dir_pos->sname.ofs = 0;                                             
   31fa8:	e588a004 	str	sl, [r8, #4]                                  <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   31fac:	e5883008 	str	r3, [r8, #8]                                  <== NOT EXECUTED
   31fb0:	0a000002 	beq	31fc0 <msdos_find_name_in_fat_file+0x74>      <== NOT EXECUTED
   31fb4:	e59d3078 	ldr	r3, [sp, #120]	; 0x78                         <== NOT EXECUTED
   31fb8:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   31fbc:	0a000004 	beq	31fd4 <msdos_find_name_in_fat_file+0x88>      <== NOT EXECUTED
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
   31fc0:	e59dc074 	ldr	ip, [sp, #116]	; 0x74                         <== NOT EXECUTED
   31fc4:	e3a0100d 	mov	r1, #13                                       <== NOT EXECUTED
   31fc8:	e28c000c 	add	r0, ip, #12                                   <== NOT EXECUTED
   31fcc:	eb008bcd 	bl	54f08 <__aeabi_idiv>                           <== NOT EXECUTED
   31fd0:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
   31fd4:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
   31fd8:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   31fdc:	1a000006 	bne	31ffc <msdos_find_name_in_fat_file+0xb0>      <== NOT EXECUTED
   31fe0:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
   31fe4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   31fe8:	1a000003 	bne	31ffc <msdos_find_name_in_fat_file+0xb0>      <== NOT EXECUTED
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
   31fec:	e5d7300a 	ldrb	r3, [r7, #10]                                <== NOT EXECUTED
   31ff0:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
        bts2rd = fat_fd->fat_file_size;                               
   31ff4:	15954018 	ldrne	r4, [r5, #24]                               <== NOT EXECUTED
    else                                                              
      lfn_entries =                                                   
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
   31ff8:	1a000000 	bne	32000 <msdos_find_name_in_fat_file+0xb4>      <== NOT EXECUTED
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
   31ffc:	e1d740b6 	ldrh	r4, [r7, #6]                                 <== NOT EXECUTED
                                                                      
    assert(name_len > 0);                                             
                                                                      
    fat_dir_pos_init(dir_pos);                                        
                                                                      
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
   32000:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
   32004:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
   32008:	e28a0001 	add	r0, sl, #1                                    <== NOT EXECUTED
   3200c:	e58d8034 	str	r8, [sp, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    assert(name_len > 0);                                             
                                                                      
    fat_dir_pos_init(dir_pos);                                        
                                                                      
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
   32010:	e58d3048 	str	r3, [sp, #72]	; 0x48                          <== NOT EXECUTED
   32014:	e58d3044 	str	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32018:	e58d6010 	str	r6, [sp, #16]                                 <== NOT EXECUTED
   3201c:	e1a09006 	mov	r9, r6                                        <== NOT EXECUTED
   32020:	e1a0b006 	mov	fp, r6                                        <== NOT EXECUTED
   32024:	e58d6020 	str	r6, [sp, #32]                                 <== NOT EXECUTED
   32028:	e58d6014 	str	r6, [sp, #20]                                 <== NOT EXECUTED
   3202c:	e58d602c 	str	r6, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   32030:	e58d6030 	str	r6, [sp, #48]	; 0x30                          <== NOT EXECUTED
   32034:	e58d6018 	str	r6, [sp, #24]                                 <== NOT EXECUTED
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
   32038:	e58d0040 	str	r0, [sp, #64]	; 0x40                          <== NOT EXECUTED
   3203c:	e1a08005 	mov	r8, r5                                        <== NOT EXECUTED
    /*                                                                
     * Scan the directory seeing if the file is present. While        
     * doing this see if a suitable location can be found to          
     * create the entry if the name is not found.                     
     */                                                               
    while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
   32040:	ea0000de 	b	323c0 <msdos_find_name_in_fat_file+0x474>       <== NOT EXECUTED
        bool remainder_empty = false;                                 
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[2] dir_offset:%li\n", dir_offset);             
#endif                                                                
                                                                      
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
   32044:	e350001f 	cmp	r0, #31                                       <== NOT EXECUTED
   32048:	da0001d6 	ble	327a8 <msdos_find_name_in_fat_file+0x85c>     <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
   3204c:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
   32050:	0a000004 	beq	32068 <msdos_find_name_in_fat_file+0x11c>     <== NOT EXECUTED
   32054:	e59f079c 	ldr	r0, [pc, #1948]	; 327f8 <msdos_find_name_in_fat_file+0x8ac><== NOT EXECUTED
   32058:	e59f17a8 	ldr	r1, [pc, #1960]	; 32808 <msdos_find_name_in_fat_file+0x8bc><== NOT EXECUTED
   3205c:	e59f279c 	ldr	r2, [pc, #1948]	; 32800 <msdos_find_name_in_fat_file+0x8b4><== NOT EXECUTED
   32060:	e59f37a4 	ldr	r3, [pc, #1956]	; 3280c <msdos_find_name_in_fat_file+0x8c0><== NOT EXECUTED
   32064:	ebffcaf2 	bl	24c34 <__assert_func>                          <== NOT EXECUTED
   32068:	e59d1030 	ldr	r1, [sp, #48]	; 0x30                          <== NOT EXECUTED
   3206c:	e1a0c006 	mov	ip, r6                                        <== NOT EXECUTED
   32070:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   32074:	e1a06004 	mov	r6, r4                                        <== NOT EXECUTED
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (dir_entry = 0;                                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char* entry = (char*) fs_info->cl_buf + dir_entry;        
   32078:	e5974098 	ldr	r4, [r7, #152]	; 0x98                         <== NOT EXECUTED
             * to here and write the long file name if this is the start of
             * a series of empty entries. If empty_space_count is 0 then
             * we are currently not inside an empty series of entries. It
             * is a count of empty entries.                           
             */                                                       
            if (empty_space_count == 0)                               
   3207c:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
                                                                      
            /*                                                        
             * See if the entry is empty or the remainder of the directory is
             * empty ? Localise to make the code read better.         
             */                                                       
            bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==       
   32080:	e7d43005 	ldrb	r3, [r4, r5]                                 <== NOT EXECUTED
             * to here and write the long file name if this is the start of
             * a series of empty entries. If empty_space_count is 0 then
             * we are currently not inside an empty series of entries. It
             * is a count of empty entries.                           
             */                                                       
            if (empty_space_count == 0)                               
   32084:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
   32088:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   3208c:	01a02000 	moveq	r2, r0                                      <== NOT EXECUTED
   32090:	01a0b005 	moveq	fp, r5                                      <== NOT EXECUTED
            {                                                         
                empty_space_entry = dir_entry;                        
                empty_space_offset = dir_offset;                      
            }                                                         
                                                                      
            if (remainder_empty)                                      
   32094:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
             * to here and write the long file name if this is the start of
             * a series of empty entries. If empty_space_count is 0 then
             * we are currently not inside an empty series of entries. It
             * is a count of empty entries.                           
             */                                                       
            if (empty_space_count == 0)                               
   32098:	e58d2020 	str	r2, [sp, #32]                                 <== NOT EXECUTED
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (dir_entry = 0;                                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char* entry = (char*) fs_info->cl_buf + dir_entry;        
   3209c:	e0844005 	add	r4, r4, r5                                    <== NOT EXECUTED
            {                                                         
                empty_space_entry = dir_entry;                        
                empty_space_offset = dir_offset;                      
            }                                                         
                                                                      
            if (remainder_empty)                                      
   320a0:	1a00000b 	bne	320d4 <msdos_find_name_in_fat_file+0x188>     <== NOT EXECUTED
#endif                                                                
                /*                                                    
                 * If just looking and there is no more entries in the
                 * directory - return name-not-found                  
                 */                                                   
                if (!create_node)                                     
   320a4:	e59d1024 	ldr	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
   320a8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   320ac:	e1a0c005 	mov	ip, r5                                        <== NOT EXECUTED
   320b0:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
   320b4:	e1a05008 	mov	r5, r8                                        <== NOT EXECUTED
   320b8:	e59d8034 	ldr	r8, [sp, #52]	; 0x34                          <== NOT EXECUTED
   320bc:	0a0001c8 	beq	327e4 <msdos_find_name_in_fat_file+0x898>     <== NOT EXECUTED
                 * Lets go and write the directory entries. If we have not found
                 * any available space add the remaining number of entries to any that
                 * we may have already found that are just before this entry. If more
                 * are needed FAT_EOF is returned by the read and we extend the file.
                 */                                                   
                if (!empty_space_found)                               
   320c0:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
   320c4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
                {                                                     
                  empty_space_count +=                                
                    entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
   320c8:	008992a6 	addeq	r9, r9, r6, lsr #5                          <== NOT EXECUTED
                 * we may have already found that are just before this entry. If more
                 * are needed FAT_EOF is returned by the read and we extend the file.
                 */                                                   
                if (!empty_space_found)                               
                {                                                     
                  empty_space_count +=                                
   320cc:	004992ac 	subeq	r9, r9, ip, lsr #5                          <== NOT EXECUTED
   320d0:	ea0000c8 	b	323f8 <msdos_find_name_in_fat_file+0x4ac>       <== NOT EXECUTED
                  printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif                                                                
                }                                                     
                break;                                                
            }                                                         
            else if (entry_empty)                                     
   320d4:	e35300e5 	cmp	r3, #229	; 0xe5                               <== NOT EXECUTED
   320d8:	1a000009 	bne	32104 <msdos_find_name_in_fat_file+0x1b8>     <== NOT EXECUTED
            {                                                         
                if (create_node)                                      
   320dc:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   320e0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   320e4:	0a0000ac 	beq	3239c <msdos_find_name_in_fat_file+0x450>     <== NOT EXECUTED
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
   320e8:	e59d2040 	ldr	r2, [sp, #64]	; 0x40                          <== NOT EXECUTED
                if (create_node)                                      
                {                                                     
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
   320ec:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
   320f0:	e59d0010 	ldr	r0, [sp, #16]                                 <== NOT EXECUTED
   320f4:	e1590002 	cmp	r9, r2                                        <== NOT EXECUTED
   320f8:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
   320fc:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
   32100:	ea0000a5 	b	3239c <msdos_find_name_in_fat_file+0x450>       <== NOT EXECUTED
                 * A valid entry so handle it.                        
                 *                                                    
                 * If empty space has not been found we need to start the
                 * count again.                                       
                 */                                                   
                if (create_node && !empty_space_found)                
   32104:	e59d0024 	ldr	r0, [sp, #36]	; 0x24                          <== NOT EXECUTED
   32108:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3210c:	0a000003 	beq	32120 <msdos_find_name_in_fat_file+0x1d4>     <== NOT EXECUTED
   32110:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
   32114:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   32118:	01a0b002 	moveq	fp, r2                                      <== NOT EXECUTED
   3211c:	01a09002 	moveq	r9, r2                                      <== NOT EXECUTED
                                                                      
                /*                                                    
                 * Check the attribute to see if the entry is for a long
                 * file name.                                         
                 */                                                   
                if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) == 
   32120:	e5d4200b 	ldrb	r2, [r4, #11]                                <== NOT EXECUTED
   32124:	e202203f 	and	r2, r2, #63	; 0x3f                            <== NOT EXECUTED
   32128:	e352000f 	cmp	r2, #15                                       <== NOT EXECUTED
   3212c:	1a000051 	bne	32278 <msdos_find_name_in_fat_file+0x32c>     <== NOT EXECUTED
#endif                                                                
                    /*                                                
                     * If we are not already processing a LFN see if this is
                     * the first entry of a LFN ?                     
                     */                                               
                    if (lfn_start.cln == FAT_FILE_SHORT_NAME)         
   32130:	e59d2044 	ldr	r2, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32134:	e3720001 	cmn	r2, #1                                        <== NOT EXECUTED
   32138:	1a00000b 	bne	3216c <msdos_find_name_in_fat_file+0x220>     <== NOT EXECUTED
                                                                      
                        /*                                            
                         * The first entry must have the last long entry
                         * flag set.                                  
                         */                                           
                        if ((*MSDOS_DIR_ENTRY_TYPE(entry) &           
   3213c:	e3130040 	tst	r3, #64	; 0x40                                <== NOT EXECUTED
   32140:	0a000094 	beq	32398 <msdos_find_name_in_fat_file+0x44c>     <== NOT EXECUTED
                         * entry match the number we expect for this  
                         * file name. Note we do not know the number of
                         * characters in the entry so this is check further
                         * on when the characters are checked.        
                         */                                           
                        if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
   32144:	e203303f 	and	r3, r3, #63	; 0x3f                            <== NOT EXECUTED
   32148:	e15a0003 	cmp	sl, r3                                        <== NOT EXECUTED
   3214c:	1a000091 	bne	32398 <msdos_find_name_in_fat_file+0x44c>     <== NOT EXECUTED
                            continue;                                 
                                                                      
                        /*                                            
                         * Get the checksum of the short entry.       
                         */                                           
                        lfn_start.cln = dir_offset;                   
   32150:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
                        lfn_start.ofs = dir_entry;                    
   32154:	e58d5048 	str	r5, [sp, #72]	; 0x48                          <== NOT EXECUTED
                            continue;                                 
                                                                      
                        /*                                            
                         * Get the checksum of the short entry.       
                         */                                           
                        lfn_start.cln = dir_offset;                   
   32158:	e58d3044 	str	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
                        lfn_start.ofs = dir_entry;                    
                        lfn_entry = lfn_entries;                      
                        lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
   3215c:	e5d4000d 	ldrb	r0, [r4, #13]                                <== NOT EXECUTED
   32160:	e58da014 	str	sl, [sp, #20]                                 <== NOT EXECUTED
   32164:	e58d002c 	str	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   32168:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
                     * If the entry number or the check sum do not match
                     * forget this series of long directory entries. These
                     * could be orphaned entries depending on the history
                     * of the disk.                                   
                     */                                               
                    if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) & 
   3216c:	e5d43000 	ldrb	r3, [r4]                                     <== NOT EXECUTED
   32170:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   32174:	e203303f 	and	r3, r3, #63	; 0x3f                            <== NOT EXECUTED
   32178:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   3217c:	1a000003 	bne	32190 <msdos_find_name_in_fat_file+0x244>     <== NOT EXECUTED
                                       MSDOS_LAST_LONG_ENTRY_MASK)) ||
                        (lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
   32180:	e5d4300d 	ldrb	r3, [r4, #13]                                <== NOT EXECUTED
   32184:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   32188:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
   3218c:	0a000002 	beq	3219c <msdos_find_name_in_fat_file+0x250>     <== NOT EXECUTED
                    {                                                 
#if MSDOS_FIND_PRINT                                                  
                        printf ("MSFS:[4.4] no match\n");             
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
   32190:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
   32194:	e58d2044 	str	r2, [sp, #68]	; 0x44                          <== NOT EXECUTED
                        continue;                                     
   32198:	ea00007f 	b	3239c <msdos_find_name_in_fat_file+0x450>       <== NOT EXECUTED
                    }                                                 
                                                                      
                    lfn_entry--;                                      
   3219c:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
   321a0:	e3a0100d 	mov	r1, #13                                       <== NOT EXECUTED
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
   321a4:	e2432001 	sub	r2, r3, #1                                    <== NOT EXECUTED
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
   321a8:	e0010192 	mul	r1, r2, r1                                    <== NOT EXECUTED
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
   321ac:	e59d0038 	ldr	r0, [sp, #56]	; 0x38                          <== NOT EXECUTED
   321b0:	e0800001 	add	r0, r0, r1                                    <== NOT EXECUTED
   321b4:	e58d003c 	str	r0, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   321b8:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
                    p = entry + 1;                                    
   321bc:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
   321c0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                    {                                                 
#if MSDOS_FIND_PRINT > 1                                              
                        printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
                                o, i, *p, *p, name[o + i], name[o + i]);
#endif                                                                
                        if (*p == '\0')                               
   321c4:	e5d41000 	ldrb	r1, [r4]                                     <== NOT EXECUTED
   321c8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   321cc:	e58d1030 	str	r1, [sp, #48]	; 0x30                          <== NOT EXECUTED
   321d0:	1a000008 	bne	321f8 <msdos_find_name_in_fat_file+0x2ac>     <== NOT EXECUTED
                            /*                                        
                             * If this is the first entry, ie the last part of the
                             * long file name and the length does not match then
                             * the file names do not match.           
                             */                                       
                            if (((lfn_entry + 1) == lfn_entries) &&   
   321d4:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
   321d8:	e150000a 	cmp	r0, sl                                        <== NOT EXECUTED
   321dc:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   321e0:	1a00001b 	bne	32254 <msdos_find_name_in_fat_file+0x308>     <== NOT EXECUTED
   321e4:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
   321e8:	e59d1074 	ldr	r1, [sp, #116]	; 0x74                         <== NOT EXECUTED
   321ec:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   321f0:	1a00000b 	bne	32224 <msdos_find_name_in_fat_file+0x2d8>     <== NOT EXECUTED
   321f4:	ea000016 	b	32254 <msdos_find_name_in_fat_file+0x308>       <== NOT EXECUTED
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
   321f8:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
   321fc:	e59d1074 	ldr	r1, [sp, #116]	; 0x74                         <== NOT EXECUTED
   32200:	e0830000 	add	r0, r3, r0                                    <== NOT EXECUTED
   32204:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
   32208:	e58d0028 	str	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
   3220c:	aa000004 	bge	32224 <msdos_find_name_in_fat_file+0x2d8>     <== NOT EXECUTED
   32210:	e59d003c 	ldr	r0, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   32214:	e59d1030 	ldr	r1, [sp, #48]	; 0x30                          <== NOT EXECUTED
   32218:	e7d00003 	ldrb	r0, [r0, r3]                                 <== NOT EXECUTED
   3221c:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
   32220:	0a000002 	beq	32230 <msdos_find_name_in_fat_file+0x2e4>     <== NOT EXECUTED
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
   32224:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   32228:	e58d3044 	str	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
                            break;                                    
   3222c:	ea000008 	b	32254 <msdos_find_name_in_fat_file+0x308>       <== NOT EXECUTED
                        }                                             
                                                                      
                        switch (i)                                    
   32230:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
                        {                                             
                            case 4:                                   
                                p += 5;                               
   32234:	02844005 	addeq	r4, r4, #5                                  <== NOT EXECUTED
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
                            break;                                    
                        }                                             
                                                                      
                        switch (i)                                    
   32238:	0a000002 	beq	32248 <msdos_find_name_in_fat_file+0x2fc>     <== NOT EXECUTED
   3223c:	e353000a 	cmp	r3, #10                                       <== NOT EXECUTED
                                break;                                
                            case 10:                                  
                                p += 4;                               
                                break;                                
                            default:                                  
                                p += 2;                               
   32240:	12844002 	addne	r4, r4, #2                                  <== NOT EXECUTED
                        {                                             
                            case 4:                                   
                                p += 5;                               
                                break;                                
                            case 10:                                  
                                p += 4;                               
   32244:	02844004 	addeq	r4, r4, #4                                  <== NOT EXECUTED
                    p = entry + 1;                                    
                                                                      
#if MSDOS_FIND_PRINT                                                  
                    printf ("MSFS:[5] lfne:%i\n", lfn_entry);         
#endif                                                                
                    for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)     
   32248:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3224c:	e353000d 	cmp	r3, #13                                       <== NOT EXECUTED
   32250:	1affffdb 	bne	321c4 <msdos_find_name_in_fat_file+0x278>     <== NOT EXECUTED
                                p += 2;                               
                                break;                                
                        }                                             
                    }                                                 
                                                                      
                    lfn_matched = ((lfn_entry == 0) &&                
   32254:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   32258:	13a01000 	movne	r1, #0                                      <== NOT EXECUTED
   3225c:	1a000002 	bne	3226c <msdos_find_name_in_fat_file+0x320>     <== NOT EXECUTED
   32260:	e59d1044 	ldr	r1, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32264:	e2911001 	adds	r1, r1, #1                                   <== NOT EXECUTED
   32268:	13a01001 	movne	r1, #1                                      <== NOT EXECUTED
   3226c:	e20110ff 	and	r1, r1, #255	; 0xff                           <== NOT EXECUTED
   32270:	e58d2014 	str	r2, [sp, #20]                                 <== NOT EXECUTED
   32274:	ea000048 	b	3239c <msdos_find_name_in_fat_file+0x450>       <== NOT EXECUTED
                     * If a LFN has been found and it matched check the
                     * entries have all been found and the checksum is
                     * correct. If this is the case return the short file
                     * name entry.                                    
                     */                                               
                    if (lfn_matched)                                  
   32278:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   3227c:	0a00000f 	beq	322c0 <msdos_find_name_in_fat_file+0x374>     <== NOT EXECUTED
   32280:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   32284:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
                        uint8_t  cs = 0;                              
                        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
                        int      i;                                   
                                                                      
                        for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
   32288:	e7d40002 	ldrb	r0, [r4, r2]                                 <== NOT EXECUTED
   3228c:	e2131001 	ands	r1, r3, #1                                   <== NOT EXECUTED
   32290:	13a01080 	movne	r1, #128	; 0x80                             <== NOT EXECUTED
   32294:	e08030a3 	add	r3, r0, r3, lsr #1                            <== NOT EXECUTED
                    {                                                 
                        uint8_t  cs = 0;                              
                        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
                        int      i;                                   
                                                                      
                        for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
   32298:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
   3229c:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
                    {                                                 
                        uint8_t  cs = 0;                              
                        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
                        int      i;                                   
                                                                      
                        for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
   322a0:	e352000b 	cmp	r2, #11                                       <== NOT EXECUTED
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
   322a4:	e20330ff 	and	r3, r3, #255	; 0xff                           <== NOT EXECUTED
                    {                                                 
                        uint8_t  cs = 0;                              
                        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
                        int      i;                                   
                                                                      
                        for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
   322a8:	1afffff6 	bne	32288 <msdos_find_name_in_fat_file+0x33c>     <== NOT EXECUTED
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
                                                                      
                        if (lfn_entry || (lfn_checksum != cs))        
   322ac:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   322b0:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
   322b4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   322b8:	01500003 	cmpeq	r0, r3                                      <== NOT EXECUTED
   322bc:	0a00000d 	beq	322f8 <msdos_find_name_in_fat_file+0x3ac>     <== NOT EXECUTED
                     * short and they match then we have the entry. We will not
                     * match a long file name against a short file name because
                     * a long file name that generates a matching short file
                     * name is not a long file name.                  
                     */                                               
                    if (lfn_matched ||                                
   322c0:	e59d2078 	ldr	r2, [sp, #120]	; 0x78                         <== NOT EXECUTED
   322c4:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
   322c8:	1a000030 	bne	32390 <msdos_find_name_in_fat_file+0x444>     <== NOT EXECUTED
   322cc:	e59d3044 	ldr	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
   322d0:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
   322d4:	1a00002d 	bne	32390 <msdos_find_name_in_fat_file+0x444>     <== NOT EXECUTED
                        ((name_type == MSDOS_NAME_SHORT) &&           
                         (lfn_start.cln == FAT_FILE_SHORT_NAME) &&    
                         (memcmp(MSDOS_DIR_NAME(entry),               
   322d8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   322dc:	e59d1080 	ldr	r1, [sp, #128]	; 0x80                         <== NOT EXECUTED
   322e0:	e282200a 	add	r2, r2, #10                                   <== NOT EXECUTED
   322e4:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   322e8:	eb00378a 	bl	40118 <memcmp>                                 <== NOT EXECUTED
                     * short and they match then we have the entry. We will not
                     * match a long file name against a short file name because
                     * a long file name that generates a matching short file
                     * name is not a long file name.                  
                     */                                               
                    if (lfn_matched ||                                
   322ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   322f0:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
   322f4:	1a000025 	bne	32390 <msdos_find_name_in_fat_file+0x444>     <== NOT EXECUTED
   322f8:	e1a07004 	mov	r7, r4                                        <== NOT EXECUTED
   322fc:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
   32300:	e1a0600c 	mov	r6, ip                                        <== NOT EXECUTED
   32304:	e1a0c005 	mov	ip, r5                                        <== NOT EXECUTED
   32308:	e1a05008 	mov	r5, r8                                        <== NOT EXECUTED
   3230c:	e59d8034 	ldr	r8, [sp, #52]	; 0x34                          <== NOT EXECUTED
#endif                                                                
                        /*                                            
                         * We get the entry we looked for - fill the position
                         * structure and the 32 bytes of the short entry
                         */                                           
                        int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
   32310:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   32314:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   32318:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   3231c:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   32320:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   32324:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
   32328:	ebffbdfb 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                                dir_offset * bts2rd,  
                                                &dir_pos->sname.cln); 
                        if (rc != RC_OK)                              
   3232c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32330:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
   32334:	1a00012d 	bne	327f0 <msdos_find_name_in_fat_file+0x8a4>     <== NOT EXECUTED
                            return rc;                                
                                                                      
                        dir_pos->sname.ofs = dir_entry;               
                                                                      
                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)     
   32338:	e59d3044 	ldr	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
   3233c:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
                                                dir_offset * bts2rd,  
                                                &dir_pos->sname.cln); 
                        if (rc != RC_OK)                              
                            return rc;                                
                                                                      
                        dir_pos->sname.ofs = dir_entry;               
   32340:	e588c004 	str	ip, [r8, #4]                                  <== NOT EXECUTED
                                                                      
                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)     
   32344:	0a000008 	beq	3236c <msdos_find_name_in_fat_file+0x420>     <== NOT EXECUTED
                        {                                             
                          rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
   32348:	e28dc044 	add	ip, sp, #68	; 0x44                            <== NOT EXECUTED
   3234c:	e0030394 	mul	r3, r4, r3                                    <== NOT EXECUTED
   32350:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   32354:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32358:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3235c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32360:	ebffbded 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                              lfn_start.cln * bts2rd, 
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
   32364:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32368:	1a000120 	bne	327f0 <msdos_find_name_in_fat_file+0x8a4>     <== NOT EXECUTED
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
                        dir_pos->lname.ofs = lfn_start.ofs;           
   3236c:	e59d3048 	ldr	r3, [sp, #72]	; 0x48                          <== NOT EXECUTED
   32370:	e588300c 	str	r3, [r8, #12]                                 <== NOT EXECUTED
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
   32374:	e59d3044 	ldr	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
   32378:	e59d0080 	ldr	r0, [sp, #128]	; 0x80                         <== NOT EXECUTED
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
   3237c:	e5883008 	str	r3, [r8, #8]                                  <== NOT EXECUTED
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
   32380:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   32384:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   32388:	eb00378c 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
   3238c:	ea000112 	b	327dc <msdos_find_name_in_fat_file+0x890>       <== NOT EXECUTED
                               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);    
                        return RC_OK;                                 
                    }                                                 
                                                                      
                    lfn_start.cln = FAT_FILE_SHORT_NAME;              
   32390:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   32394:	e58d3044 	str	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32398:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
        assert(ret == bts2rd);                                        
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (dir_entry = 0;                                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
   3239c:	e2855020 	add	r5, r5, #32                                   <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (dir_entry = 0;                                           
   323a0:	e1550006 	cmp	r5, r6                                        <== NOT EXECUTED
   323a4:	3affff33 	bcc	32078 <msdos_find_name_in_fat_file+0x12c>     <== NOT EXECUTED
   323a8:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
   323ac:	e08c6004 	add	r6, ip, r4                                    <== NOT EXECUTED
        }                                                             
                                                                      
        if (remainder_empty)                                          
            break;                                                    
                                                                      
        dir_offset++;                                                 
   323b0:	e59dc018 	ldr	ip, [sp, #24]                                 <== NOT EXECUTED
   323b4:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
   323b8:	e58d1030 	str	r1, [sp, #48]	; 0x30                          <== NOT EXECUTED
   323bc:	e58dc018 	str	ip, [sp, #24]                                 <== NOT EXECUTED
    /*                                                                
     * Scan the directory seeing if the file is present. While        
     * doing this see if a suitable location can be found to          
     * create the entry if the name is not found.                     
     */                                                               
    while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
   323c0:	e597c098 	ldr	ip, [r7, #152]	; 0x98                         <== NOT EXECUTED
   323c4:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   323c8:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   323cc:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   323d0:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   323d4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   323d8:	ebffbf3c 	bl	220d0 <fat_file_read>                          <== NOT EXECUTED
   323dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   323e0:	1affff17 	bne	32044 <msdos_find_name_in_fat_file+0xf8>      <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * If we are not to create the entry return a not found error.    
     */                                                               
    if (!create_node)                                                 
   323e4:	e59d0024 	ldr	r0, [sp, #36]	; 0x24                          <== NOT EXECUTED
   323e8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   323ec:	e1a05008 	mov	r5, r8                                        <== NOT EXECUTED
   323f0:	e59d8034 	ldr	r8, [sp, #52]	; 0x34                          <== NOT EXECUTED
   323f4:	0a0000fa 	beq	327e4 <msdos_find_name_in_fat_file+0x898>     <== NOT EXECUTED
     * data to place in each long file name entry. First set the short
     * file name to the slot of the SFN entry. This will mean no clashes
     * in this directory.                                             
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
   323f8:	e59d1078 	ldr	r1, [sp, #120]	; 0x78                         <== NOT EXECUTED
   323fc:	e3510002 	cmp	r1, #2                                        <== NOT EXECUTED
   32400:	1a00001c 	bne	32478 <msdos_find_name_in_fat_file+0x52c>     <== NOT EXECUTED
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
                         MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
   32404:	e59d0020 	ldr	r0, [sp, #32]                                 <== NOT EXECUTED
   32408:	e020b094 	mla	r0, r4, r0, fp                                <== NOT EXECUTED
   3240c:	e28a3001 	add	r3, sl, #1                                    <== NOT EXECUTED
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 3; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '~';                                                     
   32410:	e59dc080 	ldr	ip, [sp, #128]	; 0x80                         <== NOT EXECUTED
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
                         MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
   32414:	e08302a0 	add	r0, r3, r0, lsr #5                            <== NOT EXECUTED
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 3; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '~';                                                     
   32418:	e281107c 	add	r1, r1, #124	; 0x7c                           <== NOT EXECUTED
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
                         MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
   3241c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 3; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
   32420:	e7dc2003 	ldrb	r2, [ip, r3]                                 <== NOT EXECUTED
   32424:	e3520020 	cmp	r2, #32                                       <== NOT EXECUTED
   32428:	1352002e 	cmpne	r2, #46	; 0x2e                              <== NOT EXECUTED
        *c = '~';                                                     
   3242c:	07cc1003 	strbeq	r1, [ip, r3]                               <== NOT EXECUTED
msdos_short_name_hex(char* sfn, int num)                              
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 3; i++, c++)                                      
   32430:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   32434:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
   32438:	1afffff8 	bne	32420 <msdos_find_name_in_fat_file+0x4d4>     <== NOT EXECUTED
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '~';                                                     
    *c++ = '~';                                                       
   3243c:	e59d2080 	ldr	r2, [sp, #128]	; 0x80                         <== NOT EXECUTED
   32440:	e283307b 	add	r3, r3, #123	; 0x7b                           <== NOT EXECUTED
   32444:	e5c23003 	strb	r3, [r2, #3]                                 <== NOT EXECUTED
    for (i = 0; i < 4; i++, c++)                                      
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
   32448:	e59f33c0 	ldr	r3, [pc, #960]	; 32810 <msdos_find_name_in_fat_file+0x8c4><== NOT EXECUTED
   3244c:	e59d2080 	ldr	r2, [sp, #128]	; 0x80                         <== NOT EXECUTED
   32450:	e593c048 	ldr	ip, [r3, #72]	; 0x48                          <== NOT EXECUTED
   32454:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   32458:	e1a01350 	asr	r1, r0, r3                                    <== NOT EXECUTED
   3245c:	e201100f 	and	r1, r1, #15                                   <== NOT EXECUTED
   32460:	e7dc1001 	ldrb	r1, [ip, r1]                                 <== NOT EXECUTED
   32464:	e2433004 	sub	r3, r3, #4                                    <== NOT EXECUTED
    int   i;                                                          
    for (i = 0; i < 3; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '~';                                                     
    *c++ = '~';                                                       
    for (i = 0; i < 4; i++, c++)                                      
   32468:	e3730004 	cmn	r3, #4                                        <== NOT EXECUTED
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
   3246c:	e5c21004 	strb	r1, [r2, #4]                                 <== NOT EXECUTED
   32470:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    int   i;                                                          
    for (i = 0; i < 3; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '~';                                                     
    *c++ = '~';                                                       
    for (i = 0; i < 4; i++, c++)                                      
   32474:	1afffff7 	bne	32458 <msdos_find_name_in_fat_file+0x50c>     <== NOT EXECUTED
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
                         MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
        msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);   
    }                                                                 
                                                                      
    if (lfn_entries)                                                  
   32478:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   3247c:	058da014 	streq	sl, [sp, #20]                               <== NOT EXECUTED
   32480:	0a00000d 	beq	324bc <msdos_find_name_in_fat_file+0x570>     <== NOT EXECUTED
   32484:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   32488:	e58d3014 	str	r3, [sp, #20]                                 <== NOT EXECUTED
   3248c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
            lfn_checksum =                                            
   32490:	e59dc080 	ldr	ip, [sp, #128]	; 0x80                         <== NOT EXECUTED
   32494:	e7dc0003 	ldrb	r0, [ip, r3]                                 <== NOT EXECUTED
   32498:	e2121001 	ands	r1, r2, #1                                   <== NOT EXECUTED
   3249c:	13a01080 	movne	r1, #128	; 0x80                             <== NOT EXECUTED
   324a0:	e08020a2 	add	r2, r0, r2, lsr #1                            <== NOT EXECUTED
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
   324a4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
            lfn_checksum =                                            
   324a8:	e0822001 	add	r2, r2, r1                                    <== NOT EXECUTED
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
   324ac:	e353000b 	cmp	r3, #11                                       <== NOT EXECUTED
            lfn_checksum =                                            
   324b0:	e20220ff 	and	r2, r2, #255	; 0xff                           <== NOT EXECUTED
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
   324b4:	1afffff5 	bne	32490 <msdos_find_name_in_fat_file+0x544>     <== NOT EXECUTED
   324b8:	e58d2014 	str	r2, [sp, #20]                                 <== NOT EXECUTED
     * empty_space_count is a count of empty entries in the currently 
     * read cluster so if 0 there is no space. Note, dir_offset will  
     * be at the next cluster so we can just make empty_space_offset  
     * that value.                                                    
     */                                                               
    if (empty_space_count == 0)                                       
   324bc:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   324c0:	01a0b009 	moveq	fp, r9                                      <== NOT EXECUTED
   324c4:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   324c8:	0a000005 	beq	324e4 <msdos_find_name_in_fat_file+0x598>     <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Have we read past the empty block ? If so go back and read it again.
     */                                                               
    if (dir_offset != empty_space_offset)                             
   324cc:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
   324d0:	e59d1020 	ldr	r1, [sp, #32]                                 <== NOT EXECUTED
   324d4:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
   324d8:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
   324dc:	1a000002 	bne	324ec <msdos_find_name_in_fat_file+0x5a0>     <== NOT EXECUTED
   324e0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   324e4:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
   324e8:	e58d2020 	str	r2, [sp, #32]                                 <== NOT EXECUTED
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
            {                                                         
                /* get current cluster number */                      
                int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,  
   324ec:	e59d9020 	ldr	r9, [sp, #32]                                 <== NOT EXECUTED
        read_cluster = true;                                          
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
   324f0:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
            {                                                         
                /* get current cluster number */                      
                int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,  
   324f4:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
#if MSDOS_FIND_PRINT                                                  
            printf ("MSFS:[9.4] clear write: %d\n", ret);             
#endif                                                                
            if (ret == -1)                                            
              return ret;                                             
            else if (ret != bts2rd)                                   
   324f8:	e28a0001 	add	r0, sl, #1                                    <== NOT EXECUTED
        read_cluster = true;                                          
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
   324fc:	e58d2044 	str	r2, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32500:	e58d2048 	str	r2, [sp, #72]	; 0x48                          <== NOT EXECUTED
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
            {                                                         
                /* get current cluster number */                      
                int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,  
   32504:	e0090994 	mul	r9, r4, r9                                    <== NOT EXECUTED
   32508:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
#if MSDOS_FIND_PRINT                                                  
            printf ("MSFS:[9.4] clear write: %d\n", ret);             
#endif                                                                
            if (ret == -1)                                            
              return ret;                                             
            else if (ret != bts2rd)                                   
   3250c:	e58d0028 	str	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
   32510:	e58da02c 	str	sl, [sp, #44]	; 0x2c                          <== NOT EXECUTED
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
   32514:	ea0000ac 	b	327cc <msdos_find_name_in_fat_file+0x880>       <== NOT EXECUTED
    {                                                                 
        int length = 0;                                               
                                                                      
        if (read_cluster)                                             
   32518:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3251c:	0a000023 	beq	325b0 <msdos_find_name_in_fat_file+0x664>     <== NOT EXECUTED
        {                                                             
          uint32_t new_length;                                        
#if MSDOS_FIND_PRINT                                                  
          printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);        
#endif                                                                
          ret = fat_file_read(mt_entry, fat_fd,                       
   32520:	e597c098 	ldr	ip, [r7, #152]	; 0x98                         <== NOT EXECUTED
   32524:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   32528:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   3252c:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   32530:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   32534:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32538:	ebffbee4 	bl	220d0 <fat_file_read>                          <== NOT EXECUTED
                              (empty_space_offset * bts2rd), bts2rd,  
                              fs_info->cl_buf);                       
                                                                      
          if (ret != bts2rd)                                          
   3253c:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
   32540:	0a00001a 	beq	325b0 <msdos_find_name_in_fat_file+0x664>     <== NOT EXECUTED
          {                                                           
            if (ret != FAT_EOF)                                       
   32544:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32548:	1a000096 	bne	327a8 <msdos_find_name_in_fat_file+0x85c>     <== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
                                                                      
#if MSDOS_FIND_PRINT                                                  
            printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif                                                                
            ret = fat_file_extend (mt_entry, fat_fd, empty_space_offset * bts2rd,
   3254c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32550:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   32554:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   32558:	e28d304c 	add	r3, sp, #76	; 0x4c                            <== NOT EXECUTED
   3255c:	ebffbdda 	bl	21ccc <fat_file_extend>                        <== NOT EXECUTED
                                   &new_length);                      
                                                                      
            if (ret != RC_OK)                                         
   32560:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   32564:	11a00001 	movne	r0, r1                                      <== NOT EXECUTED
   32568:	1a0000a0 	bne	327f0 <msdos_find_name_in_fat_file+0x8a4>     <== NOT EXECUTED
              return ret;                                             
                                                                      
#if MSDOS_FIND_PRINT                                                  
            printf ("MSFS:[9.3] extended: %d <-> %d\n", new_length, empty_space_offset * bts2rd);
#endif                                                                
            if (new_length != (empty_space_offset * bts2rd))          
   3256c:	e59d304c 	ldr	r3, [sp, #76]	; 0x4c                          <== NOT EXECUTED
   32570:	e1530009 	cmp	r3, r9                                        <== NOT EXECUTED
   32574:	1a00008b 	bne	327a8 <msdos_find_name_in_fat_file+0x85c>     <== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
                                                                      
            memset(fs_info->cl_buf, 0, bts2rd);                       
   32578:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   3257c:	e5970098 	ldr	r0, [r7, #152]	; 0x98                         <== NOT EXECUTED
   32580:	eb003795 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
            ret = fat_file_write(mt_entry, fat_fd,                    
   32584:	e597c098 	ldr	ip, [r7, #152]	; 0x98                         <== NOT EXECUTED
   32588:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   3258c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32590:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   32594:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   32598:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   3259c:	ebffbe3e 	bl	21e9c <fat_file_write>                         <== NOT EXECUTED
                                 empty_space_offset * bts2rd,         
                                 bts2rd, fs_info->cl_buf);            
#if MSDOS_FIND_PRINT                                                  
            printf ("MSFS:[9.4] clear write: %d\n", ret);             
#endif                                                                
            if (ret == -1)                                            
   325a0:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
   325a4:	0a000090 	beq	327ec <msdos_find_name_in_fat_file+0x8a0>     <== NOT EXECUTED
              return ret;                                             
            else if (ret != bts2rd)                                   
   325a8:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
   325ac:	1a00007d 	bne	327a8 <msdos_find_name_in_fat_file+0x85c>     <== NOT EXECUTED
   325b0:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   325b4:	e59dc028 	ldr	ip, [sp, #40]	; 0x28                          <== NOT EXECUTED
   325b8:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   325bc:	e2813001 	add	r3, r1, #1                                    <== NOT EXECUTED
   325c0:	e1e02001 	mvn	r2, r1                                        <== NOT EXECUTED
   325c4:	e59d1038 	ldr	r1, [sp, #56]	; 0x38                          <== NOT EXECUTED
   325c8:	e0822000 	add	r2, r2, r0                                    <== NOT EXECUTED
   325cc:	e063300c 	rsb	r3, r3, ip                                    <== NOT EXECUTED
   325d0:	e3a0c00d 	mov	ip, #13                                       <== NOT EXECUTED
   325d4:	e021129c 	mla	r1, ip, r2, r1                                <== NOT EXECUTED
   325d8:	e20330ff 	and	r3, r3, #255	; 0xff                           <== NOT EXECUTED
   325dc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   325e0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   325e4:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
   325e8:	e58d1024 	str	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
   325ec:	e1a03009 	mov	r3, r9                                        <== NOT EXECUTED
   325f0:	e1a0a00b 	mov	sl, fp                                        <== NOT EXECUTED
   325f4:	e58d0018 	str	r0, [sp, #24]                                 <== NOT EXECUTED
   325f8:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
   325fc:	e1a09002 	mov	r9, r2                                        <== NOT EXECUTED
   32600:	ea000055 	b	3275c <msdos_find_name_in_fat_file+0x810>       <== NOT EXECUTED
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
   32604:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
   32608:	e59d1028 	ldr	r1, [sp, #40]	; 0x28                          <== NOT EXECUTED
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
            lfn_entry++;                                              
   3260c:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
                                                                      
        for (dir_entry = empty_space_entry;                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
   32610:	e5976098 	ldr	r6, [r7, #152]	; 0x98                         <== NOT EXECUTED
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
   32614:	e2822020 	add	r2, r2, #32                                   <== NOT EXECUTED
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
   32618:	e15c0001 	cmp	ip, r1                                        <== NOT EXECUTED
                                                                      
        for (dir_entry = empty_space_entry;                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
   3261c:	e086600a 	add	r6, r6, sl                                    <== NOT EXECUTED
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
   32620:	e58d2018 	str	r2, [sp, #24]                                 <== NOT EXECUTED
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
   32624:	1a00001f 	bne	326a8 <msdos_find_name_in_fat_file+0x75c>     <== NOT EXECUTED
   32628:	e1a05009 	mov	r5, r9                                        <== NOT EXECUTED
            {                                                         
                /* get current cluster number */                      
                int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,  
   3262c:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   32630:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32634:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   32638:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
   3263c:	e1a09003 	mov	r9, r3                                        <== NOT EXECUTED
   32640:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
   32644:	ebffbd34 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                        empty_space_offset * bts2rd,  
                                        &dir_pos->sname.cln);         
                if (rc != RC_OK)                                      
   32648:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3264c:	1a000067 	bne	327f0 <msdos_find_name_in_fat_file+0x8a4>     <== NOT EXECUTED
                  return rc;                                          
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
   32650:	e59d3044 	ldr	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32654:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
                                        empty_space_offset * bts2rd,  
                                        &dir_pos->sname.cln);         
                if (rc != RC_OK)                                      
                  return rc;                                          
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
   32658:	e588a004 	str	sl, [r8, #4]                                  <== NOT EXECUTED
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
   3265c:	0a000008 	beq	32684 <msdos_find_name_in_fat_file+0x738>     <== NOT EXECUTED
                {                                                     
                  rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,    
   32660:	e28dc044 	add	ip, sp, #68	; 0x44                            <== NOT EXECUTED
   32664:	e0030394 	mul	r3, r4, r3                                    <== NOT EXECUTED
   32668:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   3266c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32670:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   32674:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32678:	ebffbd27 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                      lfn_start.cln * bts2rd,         
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
   3267c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32680:	1a00005a 	bne	327f0 <msdos_find_name_in_fat_file+0x8a4>     <== NOT EXECUTED
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
   32684:	e59d3044 	ldr	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
   32688:	e5883008 	str	r3, [r8, #8]                                  <== NOT EXECUTED
                dir_pos->lname.ofs = lfn_start.ofs;                   
   3268c:	e59d3048 	ldr	r3, [sp, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
   32690:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
                dir_pos->lname.ofs = lfn_start.ofs;                   
   32694:	e588300c 	str	r3, [r8, #12]                                 <== NOT EXECUTED
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
   32698:	e59d1080 	ldr	r1, [sp, #128]	; 0x80                         <== NOT EXECUTED
   3269c:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   326a0:	eb0036c6 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                        MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);           
                break;                                                
   326a4:	ea000031 	b	32770 <msdos_find_name_in_fat_file+0x824>       <== NOT EXECUTED
             * This is a long file name and we need to write          
             * a long file name entry. See if this is the             
             * first entry written and if so remember the             
             * the location of the long file name.                    
             */                                                       
            if (lfn_start.cln == FAT_FILE_SHORT_NAME)                 
   326a8:	e59d2044 	ldr	r2, [sp, #68]	; 0x44                          <== NOT EXECUTED
   326ac:	e3720001 	cmn	r2, #1                                        <== NOT EXECUTED
            {                                                         
              lfn_start.cln = empty_space_offset;                     
   326b0:	059d0020 	ldreq	r0, [sp, #32]                               <== NOT EXECUTED
            }                                                         
                                                                      
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
   326b4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
             * first entry written and if so remember the             
             * the location of the long file name.                    
             */                                                       
            if (lfn_start.cln == FAT_FILE_SHORT_NAME)                 
            {                                                         
              lfn_start.cln = empty_space_offset;                     
   326b8:	058d0044 	streq	r0, [sp, #68]	; 0x44                        <== NOT EXECUTED
            }                                                         
                                                                      
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
   326bc:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   326c0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   326c4:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
   326c8:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
             * the location of the long file name.                    
             */                                                       
            if (lfn_start.cln == FAT_FILE_SHORT_NAME)                 
            {                                                         
              lfn_start.cln = empty_space_offset;                     
              lfn_start.ofs = dir_entry;                              
   326cc:	058da048 	streq	sl, [sp, #72]	; 0x48                        <== NOT EXECUTED
            }                                                         
                                                                      
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
   326d0:	eb003741 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
   326d4:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
   326d8:	e5c6100d 	strb	r1, [r6, #13]                                <== NOT EXECUTED
                                                                      
            p = entry + 1;                                            
   326dc:	e59d0024 	ldr	r0, [sp, #36]	; 0x24                          <== NOT EXECUTED
   326e0:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
   326e4:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   326e8:	e2862001 	add	r2, r6, #1                                    <== NOT EXECUTED
   326ec:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
            for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)             
            {                                                         
                *p = *n;                                              
   326f0:	e5d0e000 	ldrb	lr, [r0]                                     <== NOT EXECUTED
   326f4:	e5c2e000 	strb	lr, [r2]                                     <== NOT EXECUTED
                if (*n != 0)                                          
   326f8:	e5d0e000 	ldrb	lr, [r0]                                     <== NOT EXECUTED
   326fc:	e35e0000 	cmp	lr, #0                                        <== NOT EXECUTED
                    n++;                                              
   32700:	12800001 	addne	r0, r0, #1                                  <== NOT EXECUTED
                                                                      
                switch (i)                                            
   32704:	e3510004 	cmp	r1, #4                                        <== NOT EXECUTED
                {                                                     
                    case 4:                                           
                        p += 5;                                       
   32708:	02822005 	addeq	r2, r2, #5                                  <== NOT EXECUTED
            {                                                         
                *p = *n;                                              
                if (*n != 0)                                          
                    n++;                                              
                                                                      
                switch (i)                                            
   3270c:	0a000002 	beq	3271c <msdos_find_name_in_fat_file+0x7d0>     <== NOT EXECUTED
   32710:	e351000a 	cmp	r1, #10                                       <== NOT EXECUTED
                        break;                                        
                    case 10:                                          
                        p += 4;                                       
                        break;                                        
                    default:                                          
                        p += 2;                                       
   32714:	12822002 	addne	r2, r2, #2                                  <== NOT EXECUTED
                {                                                     
                    case 4:                                           
                        p += 5;                                       
                        break;                                        
                    case 10:                                          
                        p += 4;                                       
   32718:	02822004 	addeq	r2, r2, #4                                  <== NOT EXECUTED
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
                                                                      
            p = entry + 1;                                            
            n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
            for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)             
   3271c:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
   32720:	e351000d 	cmp	r1, #13                                       <== NOT EXECUTED
   32724:	1afffff1 	bne	326f0 <msdos_find_name_in_fat_file+0x7a4>     <== NOT EXECUTED
                        break;                                        
                }                                                     
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
   32728:	e35c0001 	cmp	ip, #1                                        <== NOT EXECUTED
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
   3272c:	03852040 	orreq	r2, r5, #64	; 0x40                          <== NOT EXECUTED
                        p += 2;                                       
                        break;                                        
                }                                                     
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
   32730:	e5c65000 	strb	r5, [r6]                                     <== NOT EXECUTED
            if (lfn_entry == 1)                                       
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
   32734:	05c62000 	strbeq	r2, [r6]                                   <== NOT EXECUTED
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
   32738:	e5d6200b 	ldrb	r2, [r6, #11]                                <== NOT EXECUTED
   3273c:	e382200f 	orr	r2, r2, #15                                   <== NOT EXECUTED
   32740:	e5c6200b 	strb	r2, [r6, #11]                                <== NOT EXECUTED
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
   32744:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
   32748:	e242200d 	sub	r2, r2, #13                                   <== NOT EXECUTED
   3274c:	e2455001 	sub	r5, r5, #1                                    <== NOT EXECUTED
   32750:	e58d2024 	str	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
   32754:	e28aa020 	add	sl, sl, #32                                   <== NOT EXECUTED
   32758:	e20550ff 	and	r5, r5, #255	; 0xff                           <== NOT EXECUTED
                                                                      
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
   3275c:	e15a0004 	cmp	sl, r4                                        <== NOT EXECUTED
   32760:	3affffa7 	bcc	32604 <msdos_find_name_in_fat_file+0x6b8>     <== NOT EXECUTED
   32764:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
   32768:	e1a05009 	mov	r5, r9                                        <== NOT EXECUTED
   3276c:	e1a09003 	mov	r9, r3                                        <== NOT EXECUTED
            if (lfn_entry == 1)                                       
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
        }                                                             
                                                                      
        ret = fat_file_write(mt_entry, fat_fd,                        
   32770:	e5973098 	ldr	r3, [r7, #152]	; 0x98                         <== NOT EXECUTED
   32774:	e089200b 	add	r2, r9, fp                                    <== NOT EXECUTED
   32778:	e59d001c 	ldr	r0, [sp, #28]                                 <== NOT EXECUTED
   3277c:	e083b00b 	add	fp, r3, fp                                    <== NOT EXECUTED
   32780:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32784:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
   32788:	e58db000 	str	fp, [sp]                                      <== NOT EXECUTED
   3278c:	ebffbdc2 	bl	21e9c <fat_file_write>                         <== NOT EXECUTED
                             (empty_space_offset * bts2rd) + empty_space_entry,
                             length, fs_info->cl_buf + empty_space_entry);
        if (ret == -1)                                                
   32790:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
   32794:	0a000014 	beq	327ec <msdos_find_name_in_fat_file+0x8a0>     <== NOT EXECUTED
            return ret;                                               
        else if (ret != length)                                       
   32798:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
   3279c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
        }                                                             
                                                                      
        ret = fat_file_write(mt_entry, fat_fd,                        
                             (empty_space_offset * bts2rd) + empty_space_entry,
                             length, fs_info->cl_buf + empty_space_entry);
        if (ret == -1)                                                
   327a0:	e0899004 	add	r9, r9, r4                                    <== NOT EXECUTED
            return ret;                                               
        else if (ret != length)                                       
   327a4:	0a000003 	beq	327b8 <msdos_find_name_in_fat_file+0x86c>     <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
   327a8:	eb0029d4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   327ac:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   327b0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   327b4:	ea00000c 	b	327ec <msdos_find_name_in_fat_file+0x8a0>       <== NOT EXECUTED
                                                                      
        empty_space_offset++;                                         
   327b8:	e59dc020 	ldr	ip, [sp, #32]                                 <== NOT EXECUTED
   327bc:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
   327c0:	e58dc020 	str	ip, [sp, #32]                                 <== NOT EXECUTED
   327c4:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   327c8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
   327cc:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   327d0:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   327d4:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
   327d8:	aaffff4e 	bge	32518 <msdos_find_name_in_fat_file+0x5cc>     <== NOT EXECUTED
   327dc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   327e0:	ea000002 	b	327f0 <msdos_find_name_in_fat_file+0x8a4>       <== NOT EXECUTED
   327e4:	e59f0028 	ldr	r0, [pc, #40]	; 32814 <msdos_find_name_in_fat_file+0x8c8><== NOT EXECUTED
   327e8:	ea000000 	b	327f0 <msdos_find_name_in_fat_file+0x8a4>       <== NOT EXECUTED
   327ec:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
        empty_space_entry = 0;                                        
        read_cluster = true;                                          
    }                                                                 
                                                                      
    return 0;                                                         
}                                                                     
   327f0:	e28dd050 	add	sp, sp, #80	; 0x50                            <== NOT EXECUTED
   327f4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00031df0 <msdos_find_node_by_cluster_num_in_fat_file>: fat_file_fd_t *fat_fd, uint32_t cl4find, fat_dir_pos_t *dir_pos, char *dir_entry ) {
   31df0:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
   31df4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         bts2rd = 0;                                      
    uint32_t         i = 0, j = 0;                                    
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
   31df8:	e5911020 	ldr	r1, [r1, #32]                                 <== NOT EXECUTED
   31dfc:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              cl4find,                    
    fat_dir_pos_t                        *dir_pos,                    
    char                                 *dir_entry                   
    )                                                                 
{                                                                     
   31e00:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
   31e04:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
   31e08:	e1a09003 	mov	r9, r3                                        <== NOT EXECUTED
    int              rc = RC_OK;                                      
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   31e0c:	e5907034 	ldr	r7, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t         bts2rd = 0;                                      
    uint32_t         i = 0, j = 0;                                    
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
   31e10:	1a000008 	bne	31e38 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== NOT EXECUTED
   31e14:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
   31e18:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   31e1c:	1a000005 	bne	31e38 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
   31e20:	e5d7300a 	ldrb	r3, [r7, #10]                                <== NOT EXECUTED
   31e24:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
   31e28:	0a000002 	beq	31e38 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== NOT EXECUTED
        bts2rd = fat_fd->fat_file_size;                               
   31e2c:	e5956018 	ldr	r6, [r5, #24]                                 <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         bts2rd = 0;                                      
    uint32_t         i = 0, j = 0;                                    
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
   31e30:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   31e34:	ea000031 	b	31f00 <msdos_find_node_by_cluster_num_in_fat_file+0x110><== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
   31e38:	e1d760b6 	ldrh	r6, [r7, #6]                                 <== NOT EXECUTED
   31e3c:	eafffffb 	b	31e30 <msdos_find_node_by_cluster_num_in_fat_file+0x40><== NOT EXECUTED
                                                                      
    while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd, 
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )                
   31e40:	e350001f 	cmp	r0, #31                                       <== NOT EXECUTED
   31e44:	ca000004 	bgt	31e5c <msdos_find_node_by_cluster_num_in_fat_file+0x6c><== NOT EXECUTED
            rtems_set_errno_and_return_minus_one( EIO );              
   31e48:	eb002c2c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31e4c:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31e50:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31e54:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   31e58:	ea000034 	b	31f30 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NOT EXECUTED
                                                                      
        assert(ret == bts2rd);                                        
   31e5c:	e1500006 	cmp	r0, r6                                        <== NOT EXECUTED
   31e60:	159f00d0 	ldrne	r0, [pc, #208]	; 31f38 <msdos_find_node_by_cluster_num_in_fat_file+0x148><== NOT EXECUTED
   31e64:	159f10d0 	ldrne	r1, [pc, #208]	; 31f3c <msdos_find_node_by_cluster_num_in_fat_file+0x14c><== NOT EXECUTED
   31e68:	159f20d0 	ldrne	r2, [pc, #208]	; 31f40 <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NOT EXECUTED
   31e6c:	159f30d0 	ldrne	r3, [pc, #208]	; 31f44 <msdos_find_node_by_cluster_num_in_fat_file+0x154><== NOT EXECUTED
   31e70:	1bffcb6f 	blne	24c34 <__assert_func>                        <== NOT EXECUTED
                                                                      
        for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
   31e74:	e5973098 	ldr	r3, [r7, #152]	; 0x98                         <== NOT EXECUTED
   31e78:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   31e7c:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
                                                                      
            /* if this and all rest entries are empty - return not-found */
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
   31e80:	e7d32004 	ldrb	r2, [r3, r4]                                 <== NOT EXECUTED
   31e84:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   31e88:	0a000027 	beq	31f2c <msdos_find_node_by_cluster_num_in_fat_file+0x13c><== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
                return MSDOS_NAME_NOT_FOUND_ERR;                      
                                                                      
            /* if this entry is empty - skip it */                    
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
   31e8c:	e35200e5 	cmp	r2, #229	; 0xe5                               <== NOT EXECUTED
   31e90:	0a000015 	beq	31eec <msdos_find_node_by_cluster_num_in_fat_file+0xfc><== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_EMPTY)                           
                continue;                                             
                                                                      
            /* if get a non-empty entry - compare clusters num */     
            if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)          
   31e94:	e1d811b4 	ldrh	r1, [r8, #20]                                <== NOT EXECUTED
   31e98:	e1d821ba 	ldrh	r2, [r8, #26]                                <== NOT EXECUTED
   31e9c:	e1822801 	orr	r2, r2, r1, lsl #16                           <== NOT EXECUTED
   31ea0:	e152000c 	cmp	r2, ip                                        <== NOT EXECUTED
   31ea4:	1a000010 	bne	31eec <msdos_find_node_by_cluster_num_in_fat_file+0xfc><== NOT EXECUTED
            {                                                         
                /* on success fill aux structure and copy all 32 bytes */
                rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
   31ea8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   31eac:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   31eb0:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   31eb4:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   31eb8:	e58d9000 	str	r9, [sp]                                      <== NOT EXECUTED
   31ebc:	ebffbf16 	bl	21b1c <fat_file_ioctl>                         <== NOT EXECUTED
                                    &dir_pos->sname.cln);             
                if (rc != RC_OK)                                      
   31ec0:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   31ec4:	1a000019 	bne	31f30 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NOT EXECUTED
                    return rc;                                        
                                                                      
                dir_pos->sname.ofs = i;                               
                dir_pos->lname.cln = FAT_FILE_SHORT_NAME;             
   31ec8:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
                dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;             
   31ecc:	e589300c 	str	r3, [r9, #12]                                 <== NOT EXECUTED
                rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
                                    &dir_pos->sname.cln);             
                if (rc != RC_OK)                                      
                    return rc;                                        
                                                                      
                dir_pos->sname.ofs = i;                               
   31ed0:	e5894004 	str	r4, [r9, #4]                                  <== NOT EXECUTED
                dir_pos->lname.cln = FAT_FILE_SHORT_NAME;             
   31ed4:	e5893008 	str	r3, [r9, #8]                                  <== NOT EXECUTED
                dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;             
                                                                      
                memcpy(dir_entry, entry,                              
   31ed8:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   31edc:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   31ee0:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   31ee4:	eb0038b5 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                       MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);            
                return RC_OK;                                         
   31ee8:	ea000010 	b	31f30 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NOT EXECUTED
        if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )                
            rtems_set_errno_and_return_minus_one( EIO );              
                                                                      
        assert(ret == bts2rd);                                        
                                                                      
        for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
   31eec:	e2844020 	add	r4, r4, #32                                   <== NOT EXECUTED
   31ef0:	e1540006 	cmp	r4, r6                                        <== NOT EXECUTED
   31ef4:	e2888020 	add	r8, r8, #32                                   <== NOT EXECUTED
   31ef8:	3affffe0 	bcc	31e80 <msdos_find_node_by_cluster_num_in_fat_file+0x90><== NOT EXECUTED
   31efc:	e08aa006 	add	sl, sl, r6                                    <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
                                                                      
    while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd, 
   31f00:	e597e098 	ldr	lr, [r7, #152]	; 0x98                         <== NOT EXECUTED
   31f04:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   31f08:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   31f0c:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   31f10:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   31f14:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   31f18:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
   31f1c:	ebffc06b 	bl	220d0 <fat_file_read>                          <== NOT EXECUTED
   31f20:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31f24:	e59dc004 	ldr	ip, [sp, #4]                                  <== NOT EXECUTED
   31f28:	1affffc4 	bne	31e40 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== NOT EXECUTED
   31f2c:	e59f5014 	ldr	r5, [pc, #20]	; 31f48 <msdos_find_node_by_cluster_num_in_fat_file+0x158><== NOT EXECUTED
            }                                                         
        }                                                             
        j++;                                                          
    }                                                                 
    return MSDOS_NAME_NOT_FOUND_ERR;                                  
}                                                                     
   31f30:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   31f34:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
                                                                      

0001c558 <msdos_format>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
   1c558:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   1c55c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   1c560:	e24ddfb1 	sub	sp, sp, #708	; 0x2c4                          <== NOT EXECUTED
   1c564:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  int                  ret_val   = 0;                                 
  int                  fd        = -1;                                
  int                  i;                                             
  msdos_format_param_t fmt_params;                                    
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
   1c568:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1c56c:	e59f2c2c 	ldr	r2, [pc, #3116]	; 1d1a0 <msdos_format+0xc48>  <== NOT EXECUTED
   1c570:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1c574:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1c578:	ebffff81 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                       "formating: %s\n", devname);                   
  /*                                                                  
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
   1c57c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1c580:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1c584:	e59f2c18 	ldr	r2, [pc, #3096]	; 1d1a4 <msdos_format+0xc4c>  <== NOT EXECUTED
   1c588:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   1c58c:	ebffff7c 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                       "stat check: %s\n", devname);                  
  if (ret_val == 0) {                                                 
    rc = stat(devname, &stat_buf);                                    
   1c590:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1c594:	e28d1e27 	add	r1, sp, #624	; 0x270                          <== NOT EXECUTED
   1c598:	ebffb225 	bl	8e34 <stat>                                    <== NOT EXECUTED
    ret_val = rc;                                                     
  }                                                                   
                                                                      
  /* rtems feature: no block devices, all are character devices */    
  if ((ret_val == 0) &&                                               
   1c59c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1c5a0:	1a000007 	bne	1c5c4 <msdos_format+0x6c>                     <== NOT EXECUTED
      (!S_ISBLK(stat_buf.st_mode))) {                                 
   1c5a4:	e59d327c 	ldr	r3, [sp, #636]	; 0x27c                        <== NOT EXECUTED
   1c5a8:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   1c5ac:	e3530a06 	cmp	r3, #24576	; 0x6000                           <== NOT EXECUTED
   1c5b0:	0a0002c7 	beq	1d0d4 <msdos_format+0xb7c>                    <== NOT EXECUTED
    errno = ENOTTY;                                                   
   1c5b4:	eb008251 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c5b8:	e3a03019 	mov	r3, #25                                       <== NOT EXECUTED
   1c5bc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c5c0:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   1c5c4:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
   1c5c8:	ea000003 	b	1c5dc <msdos_format+0x84>                       <== NOT EXECUTED
                                                                      
  /* check that  device is registered as block device and lock it */  
  if (ret_val == 0) {                                                 
    dd = rtems_disk_obtain(stat_buf.st_rdev);                         
    if (dd == NULL) {                                                 
      errno = ENOTTY;                                                 
   1c5cc:	eb00824b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c5d0:	e3a03019 	mov	r3, #25                                       <== NOT EXECUTED
   1c5d4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c5d8:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   1c5dc:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   1c5e0:	ea000136 	b	1cac0 <msdos_format+0x568>                      <== NOT EXECUTED
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
	(rqdata->fat_num == 0)) {                                            
   1c5e4:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
   1c5e8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c5ec:	1a000001 	bne	1c5f8 <msdos_format+0xa0>                     <== NOT EXECUTED
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
   1c5f0:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   1c5f4:	ea000002 	b	1c604 <msdos_format+0xac>                       <== NOT EXECUTED
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
   1c5f8:	e3530006 	cmp	r3, #6                                        <== NOT EXECUTED
  uint32_t sectors_per_fat;                                           
  uint32_t data_cluster_cnt;                                          
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
   1c5fc:	83a07016 	movhi	r7, #22                                     <== NOT EXECUTED
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
   1c600:	8a0000e2 	bhi	1c990 <msdos_format+0x438>                    <== NOT EXECUTED
      fmt_params->fat_num = rqdata->fat_num;                          
   1c604:	e5cd3250 	strb	r3, [sp, #592]	; 0x250                       <== NOT EXECUTED
      ret_val = EINVAL;                                               
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0)                                                   
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1c608:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1c60c:	e5dd3250 	ldrb	r3, [sp, #592]	; 0x250                       <== NOT EXECUTED
   1c610:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1c614:	e59f2b8c 	ldr	r2, [pc, #2956]	; 1d1a8 <msdos_format+0xc50>  <== NOT EXECUTED
   1c618:	ebffff59 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
  /*                                                                  
   * determine FAT type and sectors per cluster                       
   * depends on                                                       
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->sectors_per_cluster = 1;                              
   1c61c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    if ((rqdata != NULL) &&                                           
   1c620:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
  /*                                                                  
   * determine FAT type and sectors per cluster                       
   * depends on                                                       
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->sectors_per_cluster = 1;                              
   1c624:	e58d322c 	str	r3, [sp, #556]	; 0x22c                        <== NOT EXECUTED
    if ((rqdata != NULL) &&                                           
   1c628:	0a000010 	beq	1c670 <msdos_format+0x118>                    <== NOT EXECUTED
	(rqdata->fattype == MSDOS_FMT_FAT12)) {                              
   1c62c:	e5d43014 	ldrb	r3, [r4, #20]                                <== NOT EXECUTED
   * determine FAT type and sectors per cluster                       
   * depends on                                                       
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->sectors_per_cluster = 1;                              
    if ((rqdata != NULL) &&                                           
   1c630:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   1c634:	0a000004 	beq	1c64c <msdos_format+0xf4>                     <== NOT EXECUTED
	(rqdata->fattype == MSDOS_FMT_FAT12)) {                              
      fmt_params->fattype = FAT_FAT12;                                
    }                                                                 
    else if ((rqdata != NULL) &&                                      
   1c638:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
   1c63c:	0a000002 	beq	1c64c <msdos_format+0xf4>                     <== NOT EXECUTED
	     (rqdata->fattype == MSDOS_FMT_FAT16)) {                         
      fmt_params->fattype = FAT_FAT16;                                
    }                                                                 
    else if ((rqdata != NULL) &&                                      
   1c640:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
   1c644:	1a000002 	bne	1c654 <msdos_format+0xfc>                     <== NOT EXECUTED
	     (rqdata->fattype == MSDOS_FMT_FAT32)) {                         
      fmt_params->fattype = FAT_FAT32;                                
   1c648:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   1c64c:	e5cd3252 	strb	r3, [sp, #594]	; 0x252                       <== NOT EXECUTED
   1c650:	ea000027 	b	1c6f4 <msdos_format+0x19c>                      <== NOT EXECUTED
    }                                                                 
    else if ((rqdata != NULL) &&                                      
   1c654:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c658:	0a000004 	beq	1c670 <msdos_format+0x118>                    <== NOT EXECUTED
	     (rqdata->fattype != MSDOS_FMT_FATANY)) {                        
      ret_val = -1;                                                   
      errno = EINVAL;                                                 
   1c65c:	eb008227 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c660:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1c664:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c668:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   1c66c:	ea000021 	b	1c6f8 <msdos_format+0x1a0>                      <== NOT EXECUTED
      /*                                                              
       * limiting values for disk size, fat type, sectors per cluster 
       * NOTE: maximum sect_per_clust is arbitrarily choosen with values that
       * are a compromise concerning capacity and efficency           
       */                                                             
      if (fmt_params->totl_sector_cnt                                 
   1c670:	e59d3224 	ldr	r3, [sp, #548]	; 0x224                        <== NOT EXECUTED
   1c674:	e59f2b30 	ldr	r2, [pc, #2864]	; 1d1ac <msdos_format+0xc54>  <== NOT EXECUTED
   1c678:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
          < ((uint32_t)FAT_FAT12_MAX_CLN)*8) {                        
        fmt_params->fattype = FAT_FAT12;                              
   1c67c:	93a03001 	movls	r3, #1                                      <== NOT EXECUTED
   1c680:	95cd3252 	strbls	r3, [sp, #594]	; 0x252                     <== NOT EXECUTED
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
   1c684:	90833003 	addls	r3, r3, r3                                  <== NOT EXECUTED
      /*                                                              
       * limiting values for disk size, fat type, sectors per cluster 
       * NOTE: maximum sect_per_clust is arbitrarily choosen with values that
       * are a compromise concerning capacity and efficency           
       */                                                             
      if (fmt_params->totl_sector_cnt                                 
   1c688:	9a000015 	bls	1c6e4 <msdos_format+0x18c>                    <== NOT EXECUTED
          < ((uint32_t)FAT_FAT12_MAX_CLN)*8) {                        
        fmt_params->fattype = FAT_FAT12;                              
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
      }                                                               
      else if (fmt_params->totl_sector_cnt                            
   1c68c:	e59f2b1c 	ldr	r2, [pc, #2844]	; 1d1b0 <msdos_format+0xc58>  <== NOT EXECUTED
   1c690:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
               < ((uint32_t)FAT_FAT16_MAX_CLN)*32) {                  
        fmt_params->fattype = FAT_FAT16;                              
   1c694:	93a03002 	movls	r3, #2                                      <== NOT EXECUTED
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
   1c698:	958d322c 	strls	r3, [sp, #556]	; 0x22c                      <== NOT EXECUTED
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
      }                                                               
      else if (fmt_params->totl_sector_cnt                            
               < ((uint32_t)FAT_FAT16_MAX_CLN)*32) {                  
        fmt_params->fattype = FAT_FAT16;                              
   1c69c:	95cd3252 	strbls	r3, [sp, #594]	; 0x252                     <== NOT EXECUTED
          < ((uint32_t)FAT_FAT12_MAX_CLN)*8) {                        
        fmt_params->fattype = FAT_FAT12;                              
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
      }                                                               
      else if (fmt_params->totl_sector_cnt                            
   1c6a0:	9a000010 	bls	1c6e8 <msdos_format+0x190>                    <== NOT EXECUTED
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
      }                                                               
      else {                                                          
        #define ONE_GB (1024L * 1024L * 1024L)                        
        uint32_t gigs = (total_size + ONE_GB) / ONE_GB;               
   1c6a4:	e3a02101 	mov	r2, #1073741824	; 0x40000000                  <== NOT EXECUTED
   1c6a8:	e0922007 	adds	r2, r2, r7                                   <== NOT EXECUTED
   1c6ac:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   1c6b0:	e0a33008 	adc	r3, r3, r8                                    <== NOT EXECUTED
   1c6b4:	e1a01f22 	lsr	r1, r2, #30                                   <== NOT EXECUTED
   1c6b8:	e1811103 	orr	r1, r1, r3, lsl #2                            <== NOT EXECUTED
        int b;                                                        
        fmt_params->fattype = FAT_FAT32;                              
        /* scale with the size of disk... */                          
        for (b = 31; b > 0; b--)                                      
          if ((gigs & (1 << b)) != 0)                                 
   1c6bc:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
        /* start trying with small clusters */                        
        fmt_params->sectors_per_cluster = 2;                          
      }                                                               
      else {                                                          
        #define ONE_GB (1024L * 1024L * 1024L)                        
        uint32_t gigs = (total_size + ONE_GB) / ONE_GB;               
   1c6c0:	e3a0301f 	mov	r3, #31                                       <== NOT EXECUTED
        int b;                                                        
        fmt_params->fattype = FAT_FAT32;                              
        /* scale with the size of disk... */                          
        for (b = 31; b > 0; b--)                                      
          if ((gigs & (1 << b)) != 0)                                 
   1c6c4:	e0110312 	ands	r0, r1, r2, lsl r3                           <== NOT EXECUTED
   1c6c8:	1a000001 	bne	1c6d4 <msdos_format+0x17c>                    <== NOT EXECUTED
        #define ONE_GB (1024L * 1024L * 1024L)                        
        uint32_t gigs = (total_size + ONE_GB) / ONE_GB;               
        int b;                                                        
        fmt_params->fattype = FAT_FAT32;                              
        /* scale with the size of disk... */                          
        for (b = 31; b > 0; b--)                                      
   1c6cc:	e2533001 	subs	r3, r3, #1                                   <== NOT EXECUTED
   1c6d0:	1afffffb 	bne	1c6c4 <msdos_format+0x16c>                    <== NOT EXECUTED
          if ((gigs & (1 << b)) != 0)                                 
            break;                                                    
        fmt_params->sectors_per_cluster = 1 << b;                     
   1c6d4:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   1c6d8:	e1a03312 	lsl	r3, r2, r3                                    <== NOT EXECUTED
      }                                                               
      else {                                                          
        #define ONE_GB (1024L * 1024L * 1024L)                        
        uint32_t gigs = (total_size + ONE_GB) / ONE_GB;               
        int b;                                                        
        fmt_params->fattype = FAT_FAT32;                              
   1c6dc:	e2822003 	add	r2, r2, #3                                    <== NOT EXECUTED
   1c6e0:	e5cd2252 	strb	r2, [sp, #594]	; 0x252                       <== NOT EXECUTED
        /* scale with the size of disk... */                          
        for (b = 31; b > 0; b--)                                      
          if ((gigs & (1 << b)) != 0)                                 
            break;                                                    
        fmt_params->sectors_per_cluster = 1 << b;                     
   1c6e4:	e58d322c 	str	r3, [sp, #556]	; 0x22c                        <== NOT EXECUTED
      }                                                               
    }                                                                 
    /*                                                                
     * try to use user requested cluster size                         
     */                                                               
    if ((rqdata != NULL) &&                                           
   1c6e8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1c6ec:	01a07004 	moveq	r7, r4                                      <== NOT EXECUTED
   1c6f0:	0a000003 	beq	1c704 <msdos_format+0x1ac>                    <== NOT EXECUTED
   1c6f4:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
	(rqdata->sectors_per_cluster > 0)) {                                 
   1c6f8:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
      }                                                               
    }                                                                 
    /*                                                                
     * try to use user requested cluster size                         
     */                                                               
    if ((rqdata != NULL) &&                                           
   1c6fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
	(rqdata->sectors_per_cluster > 0)) {                                 
      fmt_params->sectors_per_cluster =                               
   1c700:	158d322c 	strne	r3, [sp, #556]	; 0x22c                      <== NOT EXECUTED
     */                                                               
    for (onebit = 128;onebit >= 1;onebit = onebit>>1) {               
      if (fmt_params->sectors_per_cluster >= onebit) {                
	fmt_params->sectors_per_cluster = onebit;                            
	if (fmt_params->sectors_per_cluster                                  
	    <= 32768L/fmt_params->bytes_per_sector) {                        
   1c704:	e59da220 	ldr	sl, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1c708:	e59d322c 	ldr	r3, [sp, #556]	; 0x22c                        <== NOT EXECUTED
   1c70c:	e3a08080 	mov	r8, #128	; 0x80                               <== NOT EXECUTED
     * must be power of 2                                             
     * must be smaller than or equal to 128                           
     * sectors_per_cluster*bytes_per_sector must not be bigger than 32K
     */                                                               
    for (onebit = 128;onebit >= 1;onebit = onebit>>1) {               
      if (fmt_params->sectors_per_cluster >= onebit) {                
   1c710:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
	fmt_params->sectors_per_cluster = onebit;                            
	if (fmt_params->sectors_per_cluster                                  
   1c714:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1c718:	e3a00902 	mov	r0, #32768	; 0x8000                           <== NOT EXECUTED
     * must be power of 2                                             
     * must be smaller than or equal to 128                           
     * sectors_per_cluster*bytes_per_sector must not be bigger than 32K
     */                                                               
    for (onebit = 128;onebit >= 1;onebit = onebit>>1) {               
      if (fmt_params->sectors_per_cluster >= onebit) {                
   1c71c:	3a000004 	bcc	1c734 <msdos_format+0x1dc>                    <== NOT EXECUTED
	fmt_params->sectors_per_cluster = onebit;                            
	if (fmt_params->sectors_per_cluster                                  
   1c720:	eb00e1b4 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   1c724:	e1580000 	cmp	r8, r0                                        <== NOT EXECUTED
   1c728:	91a03008 	movls	r3, r8                                      <== NOT EXECUTED
   1c72c:	81a03008 	movhi	r3, r8                                      <== NOT EXECUTED
   1c730:	93a08001 	movls	r8, #1                                      <== NOT EXECUTED
     * check sectors per cluster.                                     
     * must be power of 2                                             
     * must be smaller than or equal to 128                           
     * sectors_per_cluster*bytes_per_sector must not be bigger than 32K
     */                                                               
    for (onebit = 128;onebit >= 1;onebit = onebit>>1) {               
   1c734:	e1b080a8 	lsrs	r8, r8, #1                                   <== NOT EXECUTED
   1c738:	1afffff4 	bne	1c710 <msdos_format+0x1b8>                    <== NOT EXECUTED
	}                                                                    
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0) {                                                 
   1c73c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
     * check sectors per cluster.                                     
     * must be power of 2                                             
     * must be smaller than or equal to 128                           
     * sectors_per_cluster*bytes_per_sector must not be bigger than 32K
     */                                                               
    for (onebit = 128;onebit >= 1;onebit = onebit>>1) {               
   1c740:	e58d322c 	str	r3, [sp, #556]	; 0x22c                        <== NOT EXECUTED
	}                                                                    
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0) {                                                 
   1c744:	1a000091 	bne	1c990 <msdos_format+0x438>                    <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1c748:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1c74c:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1c750:	e59f2a5c 	ldr	r2, [pc, #2652]	; 1d1b4 <msdos_format+0xc5c>  <== NOT EXECUTED
   1c754:	ebffff0a 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                         "sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
                                                                      
    if (fmt_params->fattype == FAT_FAT32) {                           
   1c758:	e5dd3252 	ldrb	r3, [sp, #594]	; 0x252                       <== NOT EXECUTED
   1c75c:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
   1c760:	1a000007 	bne	1c784 <msdos_format+0x22c>                    <== NOT EXECUTED
      /* recommended: for FAT32, always set reserved sector count to 32 */
      fmt_params->rsvd_sector_cnt = 32;                               
   1c764:	e283301c 	add	r3, r3, #28                                   <== NOT EXECUTED
   1c768:	e58d3228 	str	r3, [sp, #552]	; 0x228                        <== NOT EXECUTED
      /* for FAT32, always set files per root directory 0 */          
      fmt_params->files_per_root_dir = 0;                             
      /* location of copy of MBR */                                   
      fmt_params->mbr_copy_sec = 6;                                   
   1c76c:	e3a03006 	mov	r3, #6                                        <== NOT EXECUTED
   1c770:	e58d3248 	str	r3, [sp, #584]	; 0x248                        <== NOT EXECUTED
      /* location of fsinfo sector */                                 
      fmt_params->fsinfo_sec = 1;                                     
   1c774:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1c778:	e58d324c 	str	r3, [sp, #588]	; 0x24c                        <== NOT EXECUTED
                                                                      
    if (fmt_params->fattype == FAT_FAT32) {                           
      /* recommended: for FAT32, always set reserved sector count to 32 */
      fmt_params->rsvd_sector_cnt = 32;                               
      /* for FAT32, always set files per root directory 0 */          
      fmt_params->files_per_root_dir = 0;                             
   1c77c:	e58d7238 	str	r7, [sp, #568]	; 0x238                        <== NOT EXECUTED
   1c780:	ea000015 	b	1c7dc <msdos_format+0x284>                      <== NOT EXECUTED
      fmt_params->fsinfo_sec = 1;                                     
                                                                      
    }                                                                 
    else {                                                            
      /* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
      fmt_params->rsvd_sector_cnt = 1;                                
   1c784:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
      /* recommended: for FAT16, set files per root directory to 512 */
      /* for FAT12/FAT16, set files per root directory */             
      /* must fill up an even count of sectors         */             
      if ((rqdata != NULL) &&                                         
   1c788:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
      fmt_params->fsinfo_sec = 1;                                     
                                                                      
    }                                                                 
    else {                                                            
      /* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
      fmt_params->rsvd_sector_cnt = 1;                                
   1c78c:	e58d3228 	str	r3, [sp, #552]	; 0x228                        <== NOT EXECUTED
      /* recommended: for FAT16, set files per root directory to 512 */
      /* for FAT12/FAT16, set files per root directory */             
      /* must fill up an even count of sectors         */             
      if ((rqdata != NULL) &&                                         
   1c790:	0a000002 	beq	1c7a0 <msdos_format+0x248>                    <== NOT EXECUTED
	  (rqdata->files_per_root_dir > 0)) {                                
   1c794:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
      /* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
      fmt_params->rsvd_sector_cnt = 1;                                
      /* recommended: for FAT16, set files per root directory to 512 */
      /* for FAT12/FAT16, set files per root directory */             
      /* must fill up an even count of sectors         */             
      if ((rqdata != NULL) &&                                         
   1c798:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c79c:	1a000003 	bne	1c7b0 <msdos_format+0x258>                    <== NOT EXECUTED
	  (rqdata->files_per_root_dir > 0)) {                                
	fmt_params->files_per_root_dir = rqdata->files_per_root_dir;         
      }                                                               
      else {                                                          
	if (fmt_params->fattype == FAT_FAT16) {                              
   1c7a0:	e5dd3252 	ldrb	r3, [sp, #594]	; 0x252                       <== NOT EXECUTED
   1c7a4:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
	  fmt_params->files_per_root_dir = 512;                              
   1c7a8:	03a03c02 	moveq	r3, #512	; 0x200                            <== NOT EXECUTED
	}                                                                    
	else {                                                               
	  fmt_params->files_per_root_dir = 64;                               
   1c7ac:	13a03040 	movne	r3, #64	; 0x40                              <== NOT EXECUTED
   1c7b0:	e58d3238 	str	r3, [sp, #568]	; 0x238                        <== NOT EXECUTED
	}                                                                    
      }                                                               
      fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
   1c7b4:	e59d1220 	ldr	r1, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1c7b8:	e59d8238 	ldr	r8, [sp, #568]	; 0x238                        <== NOT EXECUTED
   1c7bc:	e1a01081 	lsl	r1, r1, #1                                    <== NOT EXECUTED
   1c7c0:	e1a012a1 	lsr	r1, r1, #5                                    <== NOT EXECUTED
   1c7c4:	e2488001 	sub	r8, r8, #1                                    <== NOT EXECUTED
   1c7c8:	e0888001 	add	r8, r8, r1                                    <== NOT EXECUTED
			    (2*fmt_params->bytes_per_sector/                               
			     FAT_DIRENTRY_SIZE-1));                                        
      fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
   1c7cc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   1c7d0:	eb00e21c 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   1c7d4:	e0600008 	rsb	r0, r0, r8                                    <== NOT EXECUTED
   1c7d8:	e58d0238 	str	r0, [sp, #568]	; 0x238                        <== NOT EXECUTED
			     (2*fmt_params->bytes_per_sector                               
			      /FAT_DIRENTRY_SIZE));                                        
    }                                                                 
    fmt_params->root_dir_sectors =                                    
      (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)          
	+ fmt_params->bytes_per_sector - 1)                                  
   1c7dc:	e59da220 	ldr	sl, [sp, #544]	; 0x220                        <== NOT EXECUTED
      fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
			     (2*fmt_params->bytes_per_sector                               
			      /FAT_DIRENTRY_SIZE));                                        
    }                                                                 
    fmt_params->root_dir_sectors =                                    
      (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)          
   1c7e0:	e59d0238 	ldr	r0, [sp, #568]	; 0x238                        <== NOT EXECUTED
   1c7e4:	e24a3001 	sub	r3, sl, #1                                    <== NOT EXECUTED
   1c7e8:	e0830280 	add	r0, r3, r0, lsl #5                            <== NOT EXECUTED
   1c7ec:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1c7f0:	eb00e180 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
	+ fmt_params->bytes_per_sector - 1)                                  
       / fmt_params->bytes_per_sector);                               
  }                                                                   
  if (ret_val == 0) {                                                 
    fatdata_sect_cnt = (fmt_params->totl_sector_cnt -                 
   1c7f4:	e28d1f89 	add	r1, sp, #548	; 0x224                          <== NOT EXECUTED
   1c7f8:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
      fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
			     (2*fmt_params->bytes_per_sector                               
			      /FAT_DIRENTRY_SIZE));                                        
    }                                                                 
    fmt_params->root_dir_sectors =                                    
      (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)          
   1c7fc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
	+ fmt_params->bytes_per_sector - 1)                                  
       / fmt_params->bytes_per_sector);                               
  }                                                                   
  if (ret_val == 0) {                                                 
    fatdata_sect_cnt = (fmt_params->totl_sector_cnt -                 
   1c800:	e0622001 	rsb	r2, r2, r1                                    <== NOT EXECUTED
   1c804:	e0632002 	rsb	r2, r3, r2                                    <== NOT EXECUTED
  uint32_t sectors_per_fat;                                           
  uint32_t data_cluster_cnt;                                          
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
   1c808:	e3a00902 	mov	r0, #32768	; 0x8000                           <== NOT EXECUTED
   1c80c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
      (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)          
	+ fmt_params->bytes_per_sector - 1)                                  
       / fmt_params->bytes_per_sector);                               
  }                                                                   
  if (ret_val == 0) {                                                 
    fatdata_sect_cnt = (fmt_params->totl_sector_cnt -                 
   1c810:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
			     FAT_DIRENTRY_SIZE-1));                                        
      fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
			     (2*fmt_params->bytes_per_sector                               
			      /FAT_DIRENTRY_SIZE));                                        
    }                                                                 
    fmt_params->root_dir_sectors =                                    
   1c814:	e58d323c 	str	r3, [sp, #572]	; 0x23c                        <== NOT EXECUTED
  uint32_t sectors_per_fat;                                           
  uint32_t data_cluster_cnt;                                          
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
   1c818:	eb00e176 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
    ret_val = msdos_format_eval_sectors_per_cluster                   
      (fmt_params->fattype,                                           
       fmt_params->bytes_per_sector,                                  
       fatdata_sect_cnt,                                              
       fmt_params->fat_num,                                           
   1c81c:	e5dd2250 	ldrb	r2, [sp, #592]	; 0x250                       <== NOT EXECUTED
                                                                      
    /*                                                                
     * check values to get legal arrangement of FAT type and cluster count
     */                                                               
                                                                      
    ret_val = msdos_format_eval_sectors_per_cluster                   
   1c820:	e5dd9252 	ldrb	r9, [sp, #594]	; 0x252                       <== NOT EXECUTED
      (fmt_params->fattype,                                           
       fmt_params->bytes_per_sector,                                  
       fatdata_sect_cnt,                                              
       fmt_params->fat_num,                                           
   1c824:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * check values to get legal arrangement of FAT type and cluster count
     */                                                               
                                                                      
    ret_val = msdos_format_eval_sectors_per_cluster                   
   1c828:	e59d822c 	ldr	r8, [sp, #556]	; 0x22c                        <== NOT EXECUTED
   1c82c:	ea000000 	b	1c834 <msdos_format+0x2dc>                      <== NOT EXECUTED
  uint32_t data_cluster_cnt;                                          
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
    sectors_per_cluster /= 2;                                         
   1c830:	e1a080a8 	lsr	r8, r8, #1                                    <== NOT EXECUTED
  uint32_t sectors_per_fat;                                           
  uint32_t data_cluster_cnt;                                          
  /*                                                                  
   * ensure, that maximum cluster size (32KByte) is not exceeded      
   */                                                                 
  while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
   1c834:	e1500008 	cmp	r0, r8                                        <== NOT EXECUTED
   1c838:	3afffffc 	bcc	1c830 <msdos_format+0x2d8>                    <== NOT EXECUTED
    }                                                                 
    else { /* FAT32 */                                                
      fat_capacity = fatdata_cluster_cnt * 4;                         
    }                                                                 
                                                                      
    sectors_per_fat = ((fat_capacity                                  
   1c83c:	e24a3001 	sub	r3, sl, #1                                    <== NOT EXECUTED
   1c840:	e58d3014 	str	r3, [sp, #20]                                 <== NOT EXECUTED
   1c844:	e58d7018 	str	r7, [sp, #24]                                 <== NOT EXECUTED
     * compute number of data clusters for current data:              
     * - compute cluster count for data AND fat                       
     * - compute storage size for FAT                                 
     * - subtract from total cluster count                            
     */                                                               
    fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;        
   1c848:	e59d0010 	ldr	r0, [sp, #16]                                 <== NOT EXECUTED
   1c84c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1c850:	eb00e168 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
    if (fattype == FAT_FAT12) {                                       
   1c854:	e3590001 	cmp	r9, #1                                        <== NOT EXECUTED
     * compute number of data clusters for current data:              
     * - compute cluster count for data AND fat                       
     * - compute storage size for FAT                                 
     * - subtract from total cluster count                            
     */                                                               
    fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;        
   1c858:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    if (fattype == FAT_FAT12) {                                       
      fat_capacity = fatdata_cluster_cnt * 3 / 2;                     
   1c85c:	03a00003 	moveq	r0, #3                                      <== NOT EXECUTED
   1c860:	00000097 	muleq	r0, r7, r0                                  <== NOT EXECUTED
   1c864:	01a000a0 	lsreq	r0, r0, #1                                  <== NOT EXECUTED
     * - compute cluster count for data AND fat                       
     * - compute storage size for FAT                                 
     * - subtract from total cluster count                            
     */                                                               
    fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;        
    if (fattype == FAT_FAT12) {                                       
   1c868:	0a000002 	beq	1c878 <msdos_format+0x320>                    <== NOT EXECUTED
      fat_capacity = fatdata_cluster_cnt * 3 / 2;                     
    }                                                                 
    else if (fattype == FAT_FAT16) {                                  
   1c86c:	e3590002 	cmp	r9, #2                                        <== NOT EXECUTED
      fat_capacity = fatdata_cluster_cnt * 2;                         
   1c870:	01a00087 	lsleq	r0, r7, #1                                  <== NOT EXECUTED
    }                                                                 
    else { /* FAT32 */                                                
      fat_capacity = fatdata_cluster_cnt * 4;                         
   1c874:	11a00107 	lslne	r0, r7, #2                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    sectors_per_fat = ((fat_capacity                                  
   1c878:	e59dc014 	ldr	ip, [sp, #20]                                 <== NOT EXECUTED
   1c87c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1c880:	e08c0000 	add	r0, ip, r0                                    <== NOT EXECUTED
   1c884:	eb00e15b 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    data_cluster_cnt = (fatdata_cluster_cnt -                         
   1c888:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
    }                                                                 
    else { /* FAT32 */                                                
      fat_capacity = fatdata_cluster_cnt * 4;                         
    }                                                                 
                                                                      
    sectors_per_fat = ((fat_capacity                                  
   1c88c:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    data_cluster_cnt = (fatdata_cluster_cnt -                         
   1c890:	e2480001 	sub	r0, r8, #1                                    <== NOT EXECUTED
   1c894:	e0200b92 	mla	r0, r2, fp, r0                                <== NOT EXECUTED
   1c898:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1c89c:	eb00e155 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
			  + (sectors_per_cluster - 1))                                     
			 / sectors_per_cluster));                                          
    /*                                                                
     * data cluster count too big? then make sectors bigger           
     */                                                               
    if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
   1c8a0:	e59fc910 	ldr	ip, [pc, #2320]	; 1d1b8 <msdos_format+0xc60>  <== NOT EXECUTED
                                                                      
    sectors_per_fat = ((fat_capacity                                  
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    data_cluster_cnt = (fatdata_cluster_cnt -                         
   1c8a4:	e0600007 	rsb	r0, r0, r7                                    <== NOT EXECUTED
			  + (sectors_per_cluster - 1))                                     
			 / sectors_per_cluster));                                          
    /*                                                                
     * data cluster count too big? then make sectors bigger           
     */                                                               
    if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
   1c8a8:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
   1c8ac:	93a03000 	movls	r3, #0                                      <== NOT EXECUTED
   1c8b0:	83a03001 	movhi	r3, #1                                      <== NOT EXECUTED
   1c8b4:	e3590001 	cmp	r9, #1                                        <== NOT EXECUTED
   1c8b8:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   1c8bc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c8c0:	1a000008 	bne	1c8e8 <msdos_format+0x390>                    <== NOT EXECUTED
   1c8c4:	e59f28f0 	ldr	r2, [pc, #2288]	; 1d1bc <msdos_format+0xc64>  <== NOT EXECUTED
   1c8c8:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
   1c8cc:	93a03000 	movls	r3, #0                                      <== NOT EXECUTED
   1c8d0:	83a03001 	movhi	r3, #1                                      <== NOT EXECUTED
   1c8d4:	e3590002 	cmp	r9, #2                                        <== NOT EXECUTED
   1c8d8:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   1c8dc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c8e0:	02833001 	addeq	r3, r3, #1                                  <== NOT EXECUTED
   1c8e4:	0a000001 	beq	1c8f0 <msdos_format+0x398>                    <== NOT EXECUTED
        ((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
      sectors_per_cluster *= 2;                                       
   1c8e8:	e1a08088 	lsl	r8, r8, #1                                    <== NOT EXECUTED
   1c8ec:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
      finished = true;                                                
    }                                                                 
    /*                                                                
     * when maximum cluster size is exceeded, we have invalid data, abort...
     */                                                               
    if ((sectors_per_cluster * bytes_per_sector)                      
   1c8f0:	e002089a 	mul	r2, sl, r8                                    <== NOT EXECUTED
   1c8f4:	e3520902 	cmp	r2, #32768	; 0x8000                           <== NOT EXECUTED
   1c8f8:	8a000004 	bhi	1c910 <msdos_format+0x3b8>                    <== NOT EXECUTED
	> MS_BYTES_PER_CLUSTER_LIMIT) {                                      
      ret_val = EINVAL;                                               
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
   1c8fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c900:	0affffd0 	beq	1c848 <msdos_format+0x2f0>                    <== NOT EXECUTED
   1c904:	e59d7018 	ldr	r7, [sp, #24]                                 <== NOT EXECUTED
  if (ret_val != 0) {                                                 
    rtems_set_errno_and_return_minus_one(ret_val);                    
  }                                                                   
  else {                                                              
    *sectors_per_cluster_adj = sectors_per_cluster;                   
    *sectors_per_fat_ptr     = sectors_per_fat;                       
   1c908:	e58db230 	str	fp, [sp, #560]	; 0x230                        <== NOT EXECUTED
   1c90c:	ea000004 	b	1c924 <msdos_format+0x3cc>                      <== NOT EXECUTED
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
                                                                      
  if (ret_val != 0) {                                                 
    rtems_set_errno_and_return_minus_one(ret_val);                    
   1c910:	eb00817a 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c914:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1c918:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c91c:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
   1c920:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
   1c924:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
       fatdata_sect_cnt,                                              
       fmt_params->fat_num,                                           
       fmt_params->sectors_per_cluster,                               
       §ors_per_cluster_adj,                                      
       &(fmt_params->sectors_per_fat));                               
    fmt_params->sectors_per_cluster = sectors_per_cluster_adj;        
   1c928:	e58d822c 	str	r8, [sp, #556]	; 0x22c                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
   1c92c:	1a000013 	bne	1c980 <msdos_format+0x428>                    <== NOT EXECUTED
    if ((rqdata != NULL) &&                                           
   1c930:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1c934:	0a000013 	beq	1c988 <msdos_format+0x430>                    <== NOT EXECUTED
   1c938:	e5d48015 	ldrb	r8, [r4, #21]                                <== NOT EXECUTED
   1c93c:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   1c940:	0a000010 	beq	1c988 <msdos_format+0x430>                    <== NOT EXECUTED
	(rqdata->media != 0)) {                                              
      const char valid_media_codes[] =                                
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
   1c944:	e59f3874 	ldr	r3, [pc, #2164]	; 1d1c0 <msdos_format+0xc68>  <== NOT EXECUTED
   1c948:	e8930007 	ldm	r3, {r0, r1, r2}                              <== NOT EXECUTED
   1c94c:	e28d3fae 	add	r3, sp, #696	; 0x2b8                          <== NOT EXECUTED
   1c950:	e8a30003 	stmia	r3!, {r0, r1}                               <== NOT EXECUTED
      if (NULL==memchr(valid_media_codes,                             
   1c954:	e28d0fae 	add	r0, sp, #696	; 0x2b8                          <== NOT EXECUTED
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
	(rqdata->media != 0)) {                                              
      const char valid_media_codes[] =                                
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
   1c958:	e5c32000 	strb	r2, [r3]                                     <== NOT EXECUTED
      if (NULL==memchr(valid_media_codes,                             
   1c95c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1c960:	e3a02009 	mov	r2, #9                                        <== NOT EXECUTED
   1c964:	eb008db6 	bl	40044 <memchr>                                 <== NOT EXECUTED
   1c968:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
      }                                                               
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
   1c96c:	15cd8251 	strbne	r8, [sp, #593]	; 0x251                     <== NOT EXECUTED
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
	(rqdata->media != 0)) {                                              
      const char valid_media_codes[] =                                
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
      if (NULL==memchr(valid_media_codes,                             
   1c970:	1a000006 	bne	1c990 <msdos_format+0x438>                    <== NOT EXECUTED
		       rqdata->media,                                               
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
   1c974:	eb008161 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c978:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1c97c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c980:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   1c984:	ea000001 	b	1c990 <msdos_format+0x438>                      <== NOT EXECUTED
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
   1c988:	e3e03007 	mvn	r3, #7                                        <== NOT EXECUTED
   1c98c:	e5cd3251 	strb	r3, [sp, #593]	; 0x251                       <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
   1c990:	e59d023c 	ldr	r0, [sp, #572]	; 0x23c                        <== NOT EXECUTED
   1c994:	e59d3230 	ldr	r3, [sp, #560]	; 0x230                        <== NOT EXECUTED
   1c998:	e5dd1250 	ldrb	r1, [sp, #592]	; 0x250                       <== NOT EXECUTED
   1c99c:	e59d2228 	ldr	r2, [sp, #552]	; 0x228                        <== NOT EXECUTED
   1c9a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  }                                                                   
  else {                                                              
    /*                                                                
     * for FAT32: root directory is in cluster 2                      
     */                                                               
    fmt_params->root_dir_start_sec =                                  
   1c9a4:	00202193 	mlaeq	r0, r3, r1, r2                              <== NOT EXECUTED
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
    fmt_params->root_dir_start_sec =                                  
   1c9a8:	102c2193 	mlane	ip, r3, r1, r2                              <== NOT EXECUTED
     * for FAT32: root directory is in cluster 2                      
     */                                                               
    fmt_params->root_dir_start_sec =                                  
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
   1c9ac:	059d322c 	ldreq	r3, [sp, #556]	; 0x22c                      <== NOT EXECUTED
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
    fmt_params->root_dir_start_sec =                                  
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;  
   1c9b0:	158d0244 	strne	r0, [sp, #580]	; 0x244                      <== NOT EXECUTED
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
    fmt_params->root_dir_start_sec =                                  
   1c9b4:	158dc240 	strne	ip, [sp, #576]	; 0x240                      <== NOT EXECUTED
  }                                                                   
  else {                                                              
    /*                                                                
     * for FAT32: root directory is in cluster 2                      
     */                                                               
    fmt_params->root_dir_start_sec =                                  
   1c9b8:	058d0240 	streq	r0, [sp, #576]	; 0x240                      <== NOT EXECUTED
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
   1c9bc:	058d3244 	streq	r3, [sp, #580]	; 0x244                      <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine usable OEMName                                         
   */                                                                 
  if (ret_val == 0) {                                                 
   1c9c0:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   1c9c4:	1a00003a 	bne	1cab4 <msdos_format+0x55c>                    <== NOT EXECUTED
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
      int          cnt;                                               
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
   1c9c8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1c9cc:	059f37f0 	ldreq	r3, [pc, #2032]	; 1d1c4 <msdos_format+0xc6c><== NOT EXECUTED
   1c9d0:	0a000003 	beq	1c9e4 <msdos_format+0x48c>                    <== NOT EXECUTED
	(rqdata->OEMName != NULL)) {                                         
   1c9d4:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
      int          cnt;                                               
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
   1c9d8:	e59f27e4 	ldr	r2, [pc, #2020]	; 1d1c4 <msdos_format+0xc6c>  <== NOT EXECUTED
   1c9dc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1c9e0:	01a03002 	moveq	r3, r2                                      <== NOT EXECUTED
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
   1c9e4:	e59f27dc 	ldr	r2, [pc, #2012]	; 1d1c8 <msdos_format+0xc70>  <== NOT EXECUTED
   1c9e8:	e28d1e22 	add	r1, sp, #544	; 0x220                          <== NOT EXECUTED
   1c9ec:	e5920000 	ldr	r0, [r2]                                      <== NOT EXECUTED
}                                                                     
                                                                      
/*=========================================================================*\
| Function:                                                                 |
\*-------------------------------------------------------------------------*/
int msdos_format                                                      
   1c9f0:	e281803c 	add	r8, r1, #60	; 0x3c                            <== NOT EXECUTED
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
   1c9f4:	e2812034 	add	r2, r1, #52	; 0x34                            <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
   1c9f8:	e3a07020 	mov	r7, #32                                       <== NOT EXECUTED
      }                                                               
      *to = '\0';                                                     
   1c9fc:	e3a0e000 	mov	lr, #0                                        <== NOT EXECUTED
   1ca00:	ea000007 	b	1ca24 <msdos_format+0x4cc>                      <== NOT EXECUTED
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
   1ca04:	e5d3c000 	ldrb	ip, [r3]                                     <== NOT EXECUTED
   1ca08:	e080a00c 	add	sl, r0, ip                                    <== NOT EXECUTED
   1ca0c:	e5daa001 	ldrb	sl, [sl, #1]                                 <== NOT EXECUTED
   1ca10:	e31a0097 	tst	sl, #151	; 0x97                               <== NOT EXECUTED
	*to++ = *from++;                                                     
   1ca14:	1542c001 	strbne	ip, [r2, #-1]                              <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
   1ca18:	05427001 	strbeq	r7, [r2, #-1]                              <== NOT EXECUTED
      }                                                               
      *to = '\0';                                                     
   1ca1c:	e4c2e001 	strb	lr, [r2], #1                                 <== NOT EXECUTED
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
	*to++ = *from++;                                                     
   1ca20:	12833001 	addne	r3, r3, #1                                  <== NOT EXECUTED
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
	(rqdata->OEMName != NULL)) {                                         
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
   1ca24:	e1520008 	cmp	r2, r8                                        <== NOT EXECUTED
   1ca28:	1afffff5 	bne	1ca04 <msdos_format+0x4ac>                    <== NOT EXECUTED
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
    if ((rqdata != NULL) &&                                           
   1ca2c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1ca30:	0a000004 	beq	1ca48 <msdos_format+0x4f0>                    <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
   1ca34:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
    if ((rqdata != NULL) &&                                           
   1ca38:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
   1ca3c:	13a02001 	movne	r2, #1                                      <== NOT EXECUTED
   1ca40:	15cd2268 	strbne	r2, [sp, #616]	; 0x268                     <== NOT EXECUTED
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
    if ((rqdata != NULL) &&                                           
   1ca44:	1a000000 	bne	1ca4c <msdos_format+0x4f4>                    <== NOT EXECUTED
   1ca48:	e59f377c 	ldr	r3, [pc, #1916]	; 1d1cc <msdos_format+0xc74>  <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
   1ca4c:	e28d2f97 	add	r2, sp, #604	; 0x25c                          <== NOT EXECUTED
}                                                                     
                                                                      
/*=========================================================================*\
| Function:                                                                 |
\*-------------------------------------------------------------------------*/
int msdos_format                                                      
   1ca50:	e2811048 	add	r1, r1, #72	; 0x48                            <== NOT EXECUTED
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
    if ((rqdata != NULL) &&                                           
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
   1ca54:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
   1ca58:	e3a07020 	mov	r7, #32                                       <== NOT EXECUTED
      }                                                               
      *to = '\0';                                                     
   1ca5c:	e3a0e000 	mov	lr, #0                                        <== NOT EXECUTED
   1ca60:	ea000007 	b	1ca84 <msdos_format+0x52c>                      <== NOT EXECUTED
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
   1ca64:	e5d3c000 	ldrb	ip, [r3]                                     <== NOT EXECUTED
   1ca68:	e080800c 	add	r8, r0, ip                                    <== NOT EXECUTED
   1ca6c:	e5d88001 	ldrb	r8, [r8, #1]                                 <== NOT EXECUTED
   1ca70:	e3180097 	tst	r8, #151	; 0x97                               <== NOT EXECUTED
	*to++ = *from++;                                                     
   1ca74:	1542c001 	strbne	ip, [r2, #-1]                              <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
   1ca78:	05427001 	strbeq	r7, [r2, #-1]                              <== NOT EXECUTED
      }                                                               
      *to = '\0';                                                     
   1ca7c:	e4c2e001 	strb	lr, [r2], #1                                 <== NOT EXECUTED
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
	*to++ = *from++;                                                     
   1ca80:	12833001 	addne	r3, r3, #1                                  <== NOT EXECUTED
    if ((rqdata != NULL) &&                                           
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
   1ca84:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   1ca88:	1afffff5 	bne	1ca64 <msdos_format+0x50c>                    <== NOT EXECUTED
{                                                                     
  int ret_val = 0;                                                    
  int rc;                                                             
  struct timeval time_value;                                          
                                                                      
  rc = rtems_clock_get_tod_timeval(&time_value);                      
   1ca8c:	e28d0fae 	add	r0, sp, #696	; 0x2b8                          <== NOT EXECUTED
   1ca90:	ebffb9d2 	bl	b1e0 <rtems_clock_get_tod_timeval>             <== NOT EXECUTED
  if (rc == RTEMS_SUCCESSFUL) {                                       
   1ca94:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    *volid_ptr = time_value.tv_sec + time_value.tv_sec;               
   1ca98:	059d32b8 	ldreq	r3, [sp, #696]	; 0x2b8                      <== NOT EXECUTED
   1ca9c:	01a03083 	lsleq	r3, r3, #1                                  <== NOT EXECUTED
   1caa0:	058d326c 	streq	r3, [sp, #620]	; 0x26c                      <== NOT EXECUTED
  int ret_val = 0;                                                    
  int rc;                                                             
  struct timeval time_value;                                          
                                                                      
  rc = rtems_clock_get_tod_timeval(&time_value);                      
  if (rc == RTEMS_SUCCESSFUL) {                                       
   1caa4:	0a0001ad 	beq	1d160 <msdos_format+0xc08>                    <== NOT EXECUTED
    *volid_ptr = time_value.tv_sec + time_value.tv_sec;               
  }                                                                   
  else {                                                              
    *volid_ptr = rand();                                              
   1caa8:	eb009576 	bl	42088 <rand>                                   <== NOT EXECUTED
   1caac:	e58d026c 	str	r0, [sp, #620]	; 0x26c                        <== NOT EXECUTED
   1cab0:	ea0001aa 	b	1d160 <msdos_format+0xc08>                      <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * Phuuu.... That's it.                                             
   */                                                                 
  if (ret_val != 0) {                                                 
    rtems_set_errno_and_return_minus_one(ret_val);                    
   1cab4:	eb008111 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1cab8:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   1cabc:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
    ret_val = msdos_format_determine_fmt_params(dd,rqdata,&fmt_params);
  }                                                                   
  /*                                                                  
   * if requested, write whole disk/partition with 0xe5               
   */                                                                 
  if ((ret_val == 0) &&                                               
   1cac0:	e2773001 	rsbs	r3, r7, #1                                   <== NOT EXECUTED
   1cac4:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
   1cac8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1cacc:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   1cad0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1cad4:	0a00000b 	beq	1cb08 <msdos_format+0x5b0>                    <== NOT EXECUTED
      (rqdata != NULL) &&                                             
      !(rqdata->quick_format)) {                                      
   1cad8:	e5d42016 	ldrb	r2, [r4, #22]                                <== NOT EXECUTED
   1cadc:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   1cae0:	1a00000a 	bne	1cb10 <msdos_format+0x5b8>                    <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
   1cae4:	e59dc220 	ldr	ip, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1cae8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1caec:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1caf0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1caf4:	e3a0c0e5 	mov	ip, #229	; 0xe5                               <== NOT EXECUTED
   1caf8:	e59d3224 	ldr	r3, [sp, #548]	; 0x224                        <== NOT EXECUTED
   1cafc:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   1cb00:	ebfffe48 	bl	1c428 <msdos_format_fill_sectors>              <== NOT EXECUTED
   1cb04:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
       0xe5);                                                         
  }                                                                   
  /*                                                                  
   * create master boot record                                        
   */                                                                 
  if (ret_val == 0) {                                                 
   1cb08:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   1cb0c:	1a000167 	bne	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
    /*                                                                
     * Read the current MBR to obtain the partition table.            
     */                                                               
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1cb10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1cb14:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1cb18:	e59f26b0 	ldr	r2, [pc, #1712]	; 1d1d0 <msdos_format+0xc78>  <== NOT EXECUTED
   1cb1c:	ebfffe18 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
   1cb20:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1cb24:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1cb28:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   1cb2c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    /*                                                                
     * Read the current MBR to obtain the partition table.            
     */                                                               
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
                         "read MRB sector\n");                        
    ret_val = msdos_format_read_sec(fd,                               
   1cb30:	e59d7220 	ldr	r7, [sp, #544]	; 0x220                        <== NOT EXECUTED
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
   1cb34:	eb002502 	bl	25f44 <lseek>                                  <== NOT EXECUTED
   1cb38:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   1cb3c:	ba000005 	blt	1cb58 <msdos_format+0x600>                    <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > read(fd,buffer,sector_size)) {                            
   1cb40:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1cb44:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1cb48:	e28d1020 	add	r1, sp, #32                                   <== NOT EXECUTED
   1cb4c:	ebffafb0 	bl	8a14 <read>                                    <== NOT EXECUTED
   1cb50:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1cb54:	aa000183 	bge	1d168 <msdos_format+0xc10>                    <== NOT EXECUTED
   1cb58:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   1cb5c:	ea000153 	b	1d0b0 <msdos_format+0xb58>                      <== NOT EXECUTED
   1cb60:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   * finally we are there: let's fill in the values into the MBR      
   * but first clear the MRB leaving the partition table.             
   */                                                                 
#define RTEMS_IDE_PARTITION_TABLE_OFFSET                  0x1be       
#define RTEMS_IDE_PARTITION_TABLE_SIZE                    (4 * 16)    
  memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);                     
   1cb64:	e28da020 	add	sl, sp, #32                                   <== NOT EXECUTED
   1cb68:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1cb6c:	e59f2660 	ldr	r2, [pc, #1632]	; 1d1d4 <msdos_format+0xc7c>  <== NOT EXECUTED
   1cb70:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   1cb74:	eb008e18 	bl	403dc <memset>                                 <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
   1cb78:	e28d3e22 	add	r3, sp, #544	; 0x220                          <== NOT EXECUTED
   1cb7c:	e2831033 	add	r1, r3, #51	; 0x33                            <== NOT EXECUTED
   * but first clear the MRB leaving the partition table.             
   */                                                                 
#define RTEMS_IDE_PARTITION_TABLE_OFFSET                  0x1be       
#define RTEMS_IDE_PARTITION_TABLE_SIZE                    (4 * 16)    
  memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);                     
  memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
   1cb80:	e59f3650 	ldr	r3, [pc, #1616]	; 1d1d8 <msdos_format+0xc80>  <== NOT EXECUTED
   1cb84:	e3a09000 	mov	r9, #0                                        <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
   1cb88:	e3a02008 	mov	r2, #8                                        <== NOT EXECUTED
   * but first clear the MRB leaving the partition table.             
   */                                                                 
#define RTEMS_IDE_PARTITION_TABLE_OFFSET                  0x1be       
#define RTEMS_IDE_PARTITION_TABLE_SIZE                    (4 * 16)    
  memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);                     
  memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
   1cb8c:	e18a90b3 	strh	r9, [sl, r3]                                 <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
   1cb90:	e28a0003 	add	r0, sl, #3                                    <== NOT EXECUTED
   1cb94:	eb008d89 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
   1cb98:	e5ddc251 	ldrb	ip, [sp, #593]	; 0x251                       <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
   1cb9c:	e59d2228 	ldr	r2, [sp, #552]	; 0x228                        <== NOT EXECUTED
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
   1cba0:	e5dd3252 	ldrb	r3, [sp, #594]	; 0x252                       <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
   1cba4:	e58dc00c 	str	ip, [sp, #12]                                 <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
   1cba8:	e1a0c422 	lsr	ip, r2, #8                                    <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cbac:	e1a02c28 	lsr	r2, r8, #24                                   <== NOT EXECUTED
   1cbb0:	e58d201c 	str	r2, [sp, #28]                                 <== NOT EXECUTED
   1cbb4:	e1a02828 	lsr	r2, r8, #16                                   <== NOT EXECUTED
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
   1cbb8:	e59d0220 	ldr	r0, [sp, #544]	; 0x220                        <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cbbc:	e58d2018 	str	r2, [sp, #24]                                 <== NOT EXECUTED
  if (fmt_params->fattype != FAT_FAT32) {                             
   1cbc0:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
   1cbc4:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
   1cbc8:	e59d3238 	ldr	r3, [sp, #568]	; 0x238                        <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
   1cbcc:	e5cd2038 	strb	r2, [sp, #56]	; 0x38                         <== NOT EXECUTED
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
   1cbd0:	e2822007 	add	r2, r2, #7                                    <== NOT EXECUTED
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
   1cbd4:	e1a0e420 	lsr	lr, r0, #8                                    <== NOT EXECUTED
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
   1cbd8:	e5cdc02f 	strb	ip, [sp, #47]	; 0x2f                         <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
   1cbdc:	e1a00423 	lsr	r0, r3, #8                                    <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
   1cbe0:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cbe4:	e1a03428 	lsr	r3, r8, #8                                    <== NOT EXECUTED
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
   1cbe8:	e5cd203a 	strb	r2, [sp, #58]	; 0x3a                         <== NOT EXECUTED
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cbec:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
   1cbf0:	e5cd0032 	strb	r0, [sp, #50]	; 0x32                         <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cbf4:	e5cd3041 	strb	r3, [sp, #65]	; 0x41                         <== NOT EXECUTED
   1cbf8:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
   1cbfc:	e59d3220 	ldr	r3, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1cc00:	e5cde02c 	strb	lr, [sp, #44]	; 0x2c                         <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
   1cc04:	e5cdc035 	strb	ip, [sp, #53]	; 0x35                         <== NOT EXECUTED
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
   1cc08:	e59de22c 	ldr	lr, [sp, #556]	; 0x22c                        <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cc0c:	e5cd2043 	strb	r2, [sp, #67]	; 0x43                         <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
   1cc10:	e59dc228 	ldr	ip, [sp, #552]	; 0x228                        <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
   1cc14:	e59d2238 	ldr	r2, [sp, #568]	; 0x238                        <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cc18:	e5cd0042 	strb	r0, [sp, #66]	; 0x42                         <== NOT EXECUTED
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
   1cc1c:	e5cd302b 	strb	r3, [sp, #43]	; 0x2b                         <== NOT EXECUTED
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
   1cc20:	e1a0142b 	lsr	r1, fp, #8                                    <== NOT EXECUTED
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
   1cc24:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
   1cc28:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
   1cc2c:	e5cde02d 	strb	lr, [sp, #45]	; 0x2d                         <== NOT EXECUTED
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
   1cc30:	e5cd1034 	strb	r1, [sp, #52]	; 0x34                         <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
   1cc34:	e5cdc02e 	strb	ip, [sp, #46]	; 0x2e                         <== NOT EXECUTED
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
   1cc38:	e5cd0030 	strb	r0, [sp, #48]	; 0x30                         <== NOT EXECUTED
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
   1cc3c:	e5cd2031 	strb	r2, [sp, #49]	; 0x31                         <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
   1cc40:	e5cdb033 	strb	fp, [sp, #51]	; 0x33                         <== NOT EXECUTED
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
   1cc44:	e5cd9039 	strb	r9, [sp, #57]	; 0x39                         <== NOT EXECUTED
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
   1cc48:	e5cd903b 	strb	r9, [sp, #59]	; 0x3b                         <== NOT EXECUTED
   * but first clear the MRB leaving the partition table.             
   */                                                                 
#define RTEMS_IDE_PARTITION_TABLE_OFFSET                  0x1be       
#define RTEMS_IDE_PARTITION_TABLE_SIZE                    (4 * 16)    
  memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);                     
  memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
   1cc4c:	e1a07009 	mov	r7, r9                                        <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
   1cc50:	e5cd303c 	strb	r3, [sp, #60]	; 0x3c                         <== NOT EXECUTED
   1cc54:	e5cd903d 	strb	r9, [sp, #61]	; 0x3d                         <== NOT EXECUTED
   1cc58:	e5cd903e 	strb	r9, [sp, #62]	; 0x3e                         <== NOT EXECUTED
   1cc5c:	e5cd903f 	strb	r9, [sp, #63]	; 0x3f                         <== NOT EXECUTED
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
   1cc60:	e5cd8040 	strb	r8, [sp, #64]	; 0x40                         <== NOT EXECUTED
   1cc64:	e59d3230 	ldr	r3, [sp, #560]	; 0x230                        <== NOT EXECUTED
  if (fmt_params->fattype != FAT_FAT32) {                             
   1cc68:	0a00001b 	beq	1ccdc <msdos_format+0x784>                    <== NOT EXECUTED
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
   1cc6c:	e59dc26c 	ldr	ip, [sp, #620]	; 0x26c                        <== NOT EXECUTED
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
   1cc70:	e1a0e423 	lsr	lr, r3, #8                                    <== NOT EXECUTED
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
   1cc74:	e28d0e22 	add	r0, sp, #544	; 0x220                          <== NOT EXECUTED
   1cc78:	e280103c 	add	r1, r0, #60	; 0x3c                            <== NOT EXECUTED
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
   1cc7c:	e1a0bc2c 	lsr	fp, ip, #24                                   <== NOT EXECUTED
   1cc80:	e1a0842c 	lsr	r8, ip, #8                                    <== NOT EXECUTED
   1cc84:	e1a0982c 	lsr	r9, ip, #16                                   <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
   1cc88:	e3a0200b 	mov	r2, #11                                       <== NOT EXECUTED
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
   1cc8c:	e5cde037 	strb	lr, [sp, #55]	; 0x37                         <== NOT EXECUTED
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
   1cc90:	e28a002b 	add	r0, sl, #43	; 0x2b                            <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
   1cc94:	e3a0e029 	mov	lr, #41	; 0x29                                <== NOT EXECUTED
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
   1cc98:	e5cd3036 	strb	r3, [sp, #54]	; 0x36                         <== NOT EXECUTED
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
   1cc9c:	e5cd7045 	strb	r7, [sp, #69]	; 0x45                         <== NOT EXECUTED
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
   1cca0:	e5cde046 	strb	lr, [sp, #70]	; 0x46                         <== NOT EXECUTED
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
   1cca4:	e5cd8048 	strb	r8, [sp, #72]	; 0x48                         <== NOT EXECUTED
   1cca8:	e5cd9049 	strb	r9, [sp, #73]	; 0x49                         <== NOT EXECUTED
   1ccac:	e5cdb04a 	strb	fp, [sp, #74]	; 0x4a                         <== NOT EXECUTED
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
   1ccb0:	e5cd7044 	strb	r7, [sp, #68]	; 0x44                         <== NOT EXECUTED
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
   1ccb4:	e5cdc047 	strb	ip, [sp, #71]	; 0x47                         <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
   1ccb8:	eb008d40 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
	 fmt_params->VolLabel,                                               
	 FAT_BR_VOLLAB_SIZE);                                                
    memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),                           
   1ccbc:	e5dd1252 	ldrb	r1, [sp, #594]	; 0x252                       <== NOT EXECUTED
   1ccc0:	e59f3514 	ldr	r3, [pc, #1300]	; 1d1dc <msdos_format+0xc84>  <== NOT EXECUTED
   1ccc4:	e59f2514 	ldr	r2, [pc, #1300]	; 1d1e0 <msdos_format+0xc88>  <== NOT EXECUTED
   1ccc8:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
   1cccc:	01a01002 	moveq	r1, r2                                      <== NOT EXECUTED
   1ccd0:	11a01003 	movne	r1, r3                                      <== NOT EXECUTED
   1ccd4:	e28a0036 	add	r0, sl, #54	; 0x36                            <== NOT EXECUTED
   1ccd8:	ea000029 	b	1cd84 <msdos_format+0x82c>                      <== NOT EXECUTED
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
   1ccdc:	e59d2248 	ldr	r2, [sp, #584]	; 0x248                        <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
   1cce0:	e1a0c823 	lsr	ip, r3, #16                                   <== NOT EXECUTED
   1cce4:	e1a0e423 	lsr	lr, r3, #8                                    <== NOT EXECUTED
   1cce8:	e1a08c23 	lsr	r8, r3, #24                                   <== NOT EXECUTED
   1ccec:	e5cdc046 	strb	ip, [sp, #70]	; 0x46                         <== NOT EXECUTED
   1ccf0:	e5cd3044 	strb	r3, [sp, #68]	; 0x44                         <== NOT EXECUTED
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
   1ccf4:	e3a0c002 	mov	ip, #2                                        <== NOT EXECUTED
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
   1ccf8:	e59d3248 	ldr	r3, [sp, #584]	; 0x248                        <== NOT EXECUTED
   1ccfc:	e1a0b422 	lsr	fp, r2, #8                                    <== NOT EXECUTED
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
   1cd00:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1cd04:	e3a0200c 	mov	r2, #12                                       <== NOT EXECUTED
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
   1cd08:	e5cdc04c 	strb	ip, [sp, #76]	; 0x4c                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
   1cd0c:	e28d0054 	add	r0, sp, #84	; 0x54                            <== NOT EXECUTED
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
   1cd10:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
   1cd14:	e5cde045 	strb	lr, [sp, #69]	; 0x45                         <== NOT EXECUTED
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
   1cd18:	e5cdc050 	strb	ip, [sp, #80]	; 0x50                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
   1cd1c:	e5cd3052 	strb	r3, [sp, #82]	; 0x52                         <== NOT EXECUTED
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
   1cd20:	e5cd8047 	strb	r8, [sp, #71]	; 0x47                         <== NOT EXECUTED
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
   1cd24:	e5cdb053 	strb	fp, [sp, #83]	; 0x53                         <== NOT EXECUTED
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
   1cd28:	e5cd9048 	strb	r9, [sp, #72]	; 0x48                         <== NOT EXECUTED
   1cd2c:	e5cd9049 	strb	r9, [sp, #73]	; 0x49                         <== NOT EXECUTED
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
   1cd30:	e5cd904a 	strb	r9, [sp, #74]	; 0x4a                         <== NOT EXECUTED
   1cd34:	e5cd904b 	strb	r9, [sp, #75]	; 0x4b                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
   1cd38:	e5cd904d 	strb	r9, [sp, #77]	; 0x4d                         <== NOT EXECUTED
   1cd3c:	e5cd904e 	strb	r9, [sp, #78]	; 0x4e                         <== NOT EXECUTED
   1cd40:	e5cd904f 	strb	r9, [sp, #79]	; 0x4f                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
   1cd44:	e5cd9051 	strb	r9, [sp, #81]	; 0x51                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
   1cd48:	eb008da3 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    FAT_SET_BR_FAT32_DRVNUM(mbr      , 0); /* only needed for INT13... */
    FAT_SET_BR_FAT32_RSVD1(mbr       , 0); /* fill with zero */       
    FAT_SET_BR_FAT32_BOOTSIG(mbr     ,FAT_BR_FAT32_BOOTSIG_VAL);      
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
    memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr)   ,0,FAT_BR_VOLLAB_SIZE);
   1cd4c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
                                                                      
    FAT_SET_BR_FAT32_DRVNUM(mbr      , 0); /* only needed for INT13... */
    FAT_SET_BR_FAT32_RSVD1(mbr       , 0); /* fill with zero */       
    FAT_SET_BR_FAT32_BOOTSIG(mbr     ,FAT_BR_FAT32_BOOTSIG_VAL);      
   1cd50:	e3a03029 	mov	r3, #41	; 0x29                                <== NOT EXECUTED
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
    memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr)   ,0,FAT_BR_VOLLAB_SIZE);
   1cd54:	e3a0200b 	mov	r2, #11                                       <== NOT EXECUTED
   1cd58:	e28a0047 	add	r0, sl, #71	; 0x47                            <== NOT EXECUTED
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
                                                                      
    FAT_SET_BR_FAT32_DRVNUM(mbr      , 0); /* only needed for INT13... */
    FAT_SET_BR_FAT32_RSVD1(mbr       , 0); /* fill with zero */       
    FAT_SET_BR_FAT32_BOOTSIG(mbr     ,FAT_BR_FAT32_BOOTSIG_VAL);      
   1cd5c:	e5cd3062 	strb	r3, [sp, #98]	; 0x62                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
   1cd60:	e5cd9066 	strb	r9, [sp, #102]	; 0x66                        <== NOT EXECUTED
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
                                                                      
    FAT_SET_BR_FAT32_DRVNUM(mbr      , 0); /* only needed for INT13... */
   1cd64:	e5cd9060 	strb	r9, [sp, #96]	; 0x60                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_RSVD1(mbr       , 0); /* fill with zero */       
   1cd68:	e5cd9061 	strb	r9, [sp, #97]	; 0x61                         <== NOT EXECUTED
    FAT_SET_BR_FAT32_BOOTSIG(mbr     ,FAT_BR_FAT32_BOOTSIG_VAL);      
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
   1cd6c:	e5cd9063 	strb	r9, [sp, #99]	; 0x63                         <== NOT EXECUTED
   1cd70:	e5cd9064 	strb	r9, [sp, #100]	; 0x64                        <== NOT EXECUTED
   1cd74:	e5cd9065 	strb	r9, [sp, #101]	; 0x65                        <== NOT EXECUTED
    memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr)   ,0,FAT_BR_VOLLAB_SIZE);
   1cd78:	eb008d97 	bl	403dc <memset>                                 <== NOT EXECUTED
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
   1cd7c:	e59f1460 	ldr	r1, [pc, #1120]	; 1d1e4 <msdos_format+0xc8c>  <== NOT EXECUTED
   1cd80:	e28a0052 	add	r0, sl, #82	; 0x52                            <== NOT EXECUTED
   1cd84:	e3a02008 	mov	r2, #8                                        <== NOT EXECUTED
   1cd88:	eb008d0c 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  /*                                                                  
   * add boot record signature                                        
   */                                                                 
  FAT_SET_BR_SIGNATURE(mbr,      FAT_BR_SIGNATURE_VAL);               
   1cd8c:	e3a03055 	mov	r3, #85	; 0x55                                <== NOT EXECUTED
   1cd90:	e5cd321e 	strb	r3, [sp, #542]	; 0x21e                       <== NOT EXECUTED
   1cd94:	e3e03055 	mvn	r3, #85	; 0x55                                <== NOT EXECUTED
   1cd98:	e5cd321f 	strb	r3, [sp, #543]	; 0x21f                       <== NOT EXECUTED
                                                                      
  /*                                                                  
   * add jump to boot loader at start of sector                       
   */                                                                 
  FAT_SET_VAL8(mbr,0,0xeb);                                           
   1cd9c:	e2833041 	add	r3, r3, #65	; 0x41                            <== NOT EXECUTED
   1cda0:	e5cd3020 	strb	r3, [sp, #32]                                <== NOT EXECUTED
  FAT_SET_VAL8(mbr,1,0x3c);                                           
   1cda4:	e2833051 	add	r3, r3, #81	; 0x51                            <== NOT EXECUTED
    /*                                                                
     * write master boot record to disk                               
     * also write copy of MBR to disk                                 
     */                                                               
    if (ret_val == 0) {                                               
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
   1cda8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1cdac:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1cdb0:	e59f2430 	ldr	r2, [pc, #1072]	; 1d1e8 <msdos_format+0xc90>  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * add jump to boot loader at start of sector                       
   */                                                                 
  FAT_SET_VAL8(mbr,0,0xeb);                                           
  FAT_SET_VAL8(mbr,1,0x3c);                                           
   1cdb4:	e5cd3021 	strb	r3, [sp, #33]	; 0x21                         <== NOT EXECUTED
     * also write copy of MBR to disk                                 
     */                                                               
    if (ret_val == 0) {                                               
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
                           "write MRB sector\n");                     
      ret_val = msdos_format_write_sec(fd,                            
   1cdb8:	e28d8020 	add	r8, sp, #32                                   <== NOT EXECUTED
  /*                                                                  
   * add jump to boot loader at start of sector                       
   */                                                                 
  FAT_SET_VAL8(mbr,0,0xeb);                                           
  FAT_SET_VAL8(mbr,1,0x3c);                                           
  FAT_SET_VAL8(mbr,2,0x90);                                           
   1cdbc:	e3e0306f 	mvn	r3, #111	; 0x6f                               <== NOT EXECUTED
   1cdc0:	e5cd3022 	strb	r3, [sp, #34]	; 0x22                         <== NOT EXECUTED
    /*                                                                
     * write master boot record to disk                               
     * also write copy of MBR to disk                                 
     */                                                               
    if (ret_val == 0) {                                               
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
   1cdc4:	ebfffd6e 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                           "write MRB sector\n");                     
      ret_val = msdos_format_write_sec(fd,                            
   1cdc8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1cdcc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1cdd0:	e59d2220 	ldr	r2, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1cdd4:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   1cdd8:	ebfffd7e 	bl	1c3d8 <msdos_format_write_sec>                 <== NOT EXECUTED
                                       0,                             
                                       fmt_params.bytes_per_sector,   
                                       tmp_sec);                      
    }                                                                 
    if ((ret_val == 0) &&                                             
   1cddc:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1cde0:	1a0000b2 	bne	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
   1cde4:	e59d3248 	ldr	r3, [sp, #584]	; 0x248                        <== NOT EXECUTED
   1cde8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1cdec:	0a00000a 	beq	1ce1c <msdos_format+0x8c4>                    <== NOT EXECUTED
        (fmt_params.mbr_copy_sec != 0)) {                             
      /*                                                              
       * write copy of MBR                                            
       */                                                             
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
   1cdf0:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1cdf4:	e59f23f0 	ldr	r2, [pc, #1008]	; 1d1ec <msdos_format+0xc94>  <== NOT EXECUTED
   1cdf8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1cdfc:	ebfffd60 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                           "write back up MRB sector\n");             
      ret_val = msdos_format_write_sec(fd,                            
   1ce00:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ce04:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   1ce08:	e59d1248 	ldr	r1, [sp, #584]	; 0x248                        <== NOT EXECUTED
   1ce0c:	e59d2220 	ldr	r2, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1ce10:	ebfffd70 	bl	1c3d8 <msdos_format_write_sec>                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
   1ce14:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1ce18:	1a0000a4 	bne	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
   1ce1c:	e59d324c 	ldr	r3, [sp, #588]	; 0x24c                        <== NOT EXECUTED
   1ce20:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1ce24:	0a0000d9 	beq	1d190 <msdos_format+0xc38>                    <== NOT EXECUTED
\*=========================================================================*/
{                                                                     
  /*                                                                  
   * clear fsinfo sector data                                         
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
   1ce28:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1ce2c:	e3a02c02 	mov	r2, #512	; 0x200                              <== NOT EXECUTED
   1ce30:	e28d0020 	add	r0, sp, #32                                   <== NOT EXECUTED
   1ce34:	eb008d68 	bl	403dc <memset>                                 <== NOT EXECUTED
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
   1ce38:	e3a0e055 	mov	lr, #85	; 0x55                                <== NOT EXECUTED
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
   1ce3c:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
   1ce40:	e3a0c052 	mov	ip, #82	; 0x52                                <== NOT EXECUTED
   1ce44:	e3a00061 	mov	r0, #97	; 0x61                                <== NOT EXECUTED
   1ce48:	e3a01041 	mov	r1, #65	; 0x41                                <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
   1ce4c:	e3a02072 	mov	r2, #114	; 0x72                               <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
   1ce50:	e5cde21e 	strb	lr, [sp, #542]	; 0x21e                       <== NOT EXECUTED
   1ce54:	e3e0e055 	mvn	lr, #85	; 0x55                                <== NOT EXECUTED
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
   1ce58:	e5cdc021 	strb	ip, [sp, #33]	; 0x21                         <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
   1ce5c:	e5cd2205 	strb	r2, [sp, #517]	; 0x205                       <== NOT EXECUTED
   1ce60:	e5cd1206 	strb	r1, [sp, #518]	; 0x206                       <== NOT EXECUTED
   1ce64:	e5cd0207 	strb	r0, [sp, #519]	; 0x207                       <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
   1ce68:	e5cde21f 	strb	lr, [sp, #543]	; 0x21f                       <== NOT EXECUTED
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
				    0xffffffff);                                                  
  FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,              
   1ce6c:	e5cd320f 	strb	r3, [sp, #527]	; 0x20f                       <== NOT EXECUTED
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
   1ce70:	e5cdc020 	strb	ip, [sp, #32]                                <== NOT EXECUTED
   1ce74:	e5cd0022 	strb	r0, [sp, #34]	; 0x22                         <== NOT EXECUTED
   1ce78:	e5cd1023 	strb	r1, [sp, #35]	; 0x23                         <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
   1ce7c:	e5cd2204 	strb	r2, [sp, #516]	; 0x204                       <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
   1ce80:	e5cd3208 	strb	r3, [sp, #520]	; 0x208                       <== NOT EXECUTED
   1ce84:	e5cd3209 	strb	r3, [sp, #521]	; 0x209                       <== NOT EXECUTED
   1ce88:	e5cd320a 	strb	r3, [sp, #522]	; 0x20a                       <== NOT EXECUTED
   1ce8c:	e5cd320b 	strb	r3, [sp, #523]	; 0x20b                       <== NOT EXECUTED
				    0xffffffff);                                                  
  FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,              
   1ce90:	e5cd320c 	strb	r3, [sp, #524]	; 0x20c                       <== NOT EXECUTED
   1ce94:	e5cd320d 	strb	r3, [sp, #525]	; 0x20d                       <== NOT EXECUTED
   1ce98:	e5cd320e 	strb	r3, [sp, #526]	; 0x20e                       <== NOT EXECUTED
   1ce9c:	ea0000bb 	b	1d190 <msdos_format+0xc38>                      <== NOT EXECUTED
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
    ret_val = msdos_format_write_sec(fd,                              
   1cea0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1cea4:	e59d2220 	ldr	r2, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1cea8:	e28d3020 	add	r3, sp, #32                                   <== NOT EXECUTED
   1ceac:	ebfffd49 	bl	1c3d8 <msdos_format_write_sec>                 <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
   1ceb0:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1ceb4:	1a00007d 	bne	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
   1ceb8:	e59d2230 	ldr	r2, [sp, #560]	; 0x230                        <== NOT EXECUTED
   1cebc:	e59dc220 	ldr	ip, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1cec0:	e5dd3250 	ldrb	r3, [sp, #592]	; 0x250                       <== NOT EXECUTED
   1cec4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1cec8:	e0030392 	mul	r3, r2, r3                                    <== NOT EXECUTED
   1cecc:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1ced0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ced4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1ced8:	e59d2228 	ldr	r2, [sp, #552]	; 0x228                        <== NOT EXECUTED
   1cedc:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   1cee0:	ebfffd50 	bl	1c428 <msdos_format_fill_sectors>              <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * clear/init root directory                                        
   * -> write all directory sectors as 0x00                           
   */                                                                 
  if (ret_val == 0) {                                                 
   1cee4:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1cee8:	1a000070 	bne	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
   1ceec:	e59dc220 	ldr	ip, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1cef0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1cef4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1cef8:	e28d2d09 	add	r2, sp, #576	; 0x240                          <== NOT EXECUTED
   1cefc:	e892000c 	ldm	r2, {r2, r3}                                  <== NOT EXECUTED
   1cf00:	e58d7004 	str	r7, [sp, #4]                                  <== NOT EXECUTED
   1cf04:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1cf08:	ebfffd46 	bl	1c428 <msdos_format_fill_sectors>              <== NOT EXECUTED
       0x00);                                                         
  }                                                                   
  /*                                                                  
   * write volume label to first entry of directory                   
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present) {                
   1cf0c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1cf10:	1a000066 	bne	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
   1cf14:	e5dd3268 	ldrb	r3, [sp, #616]	; 0x268                       <== NOT EXECUTED
   1cf18:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1cf1c:	0a000014 	beq	1cf74 <msdos_format+0xa1c>                    <== NOT EXECUTED
    memset(tmp_sec,0,sizeof(tmp_sec));                                
   1cf20:	e28d4020 	add	r4, sp, #32                                   <== NOT EXECUTED
   1cf24:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1cf28:	e3a02c02 	mov	r2, #512	; 0x200                              <== NOT EXECUTED
   1cf2c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1cf30:	eb008d29 	bl	403dc <memset>                                 <== NOT EXECUTED
    memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
   1cf34:	e28d3f97 	add	r3, sp, #604	; 0x25c                          <== NOT EXECUTED
   1cf38:	e8930007 	ldm	r3, {r0, r1, r2}                              <== NOT EXECUTED
   1cf3c:	e1a0c004 	mov	ip, r4                                        <== NOT EXECUTED
   1cf40:	e8ac0003 	stmia	ip!, {r0, r1}                               <== NOT EXECUTED
   1cf44:	e1cc20b0 	strh	r2, [ip]                                     <== NOT EXECUTED
   1cf48:	e1a0c822 	lsr	ip, r2, #16                                   <== NOT EXECUTED
   1cf4c:	e5cdc02a 	strb	ip, [sp, #42]	; 0x2a                         <== NOT EXECUTED
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
    ret_val = msdos_format_write_sec                                  
   1cf50:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   * write volume label to first entry of directory                   
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present) {                
    memset(tmp_sec,0,sizeof(tmp_sec));                                
    memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
   1cf54:	e3a0c008 	mov	ip, #8                                        <== NOT EXECUTED
    ret_val = msdos_format_write_sec                                  
   1cf58:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1cf5c:	e59d1240 	ldr	r1, [sp, #576]	; 0x240                        <== NOT EXECUTED
   1cf60:	e59d2220 	ldr	r2, [sp, #544]	; 0x220                        <== NOT EXECUTED
   * write volume label to first entry of directory                   
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present) {                
    memset(tmp_sec,0,sizeof(tmp_sec));                                
    memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
   1cf64:	e5cdc02b 	strb	ip, [sp, #43]	; 0x2b                         <== NOT EXECUTED
    ret_val = msdos_format_write_sec                                  
   1cf68:	ebfffd1a 	bl	1c3d8 <msdos_format_write_sec>                 <== NOT EXECUTED
  /*                                                                  
   * write FAT entry 0 as (0xffffff00|Media_type)EOC,                 
   * write FAT entry 1 as EOC                                         
   * allocate directory in a FAT32 FS                                 
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present){                 
   1cf6c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1cf70:	1a00004d 	bne	1d0ac <msdos_format+0xb54>                    <== NOT EXECUTED
   1cf74:	e5dd3268 	ldrb	r3, [sp, #616]	; 0x268                       <== NOT EXECUTED
   1cf78:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1cf7c:	0a00004b 	beq	1d0b0 <msdos_format+0xb58>                    <== NOT EXECUTED
    /*                                                                
     * empty sector: all clusters are free/do not link further on     
     */                                                               
    memset(tmp_sec,0,sizeof(tmp_sec));                                
   1cf80:	e28d0020 	add	r0, sp, #32                                   <== NOT EXECUTED
   1cf84:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1cf88:	e3a02c02 	mov	r2, #512	; 0x200                              <== NOT EXECUTED
   1cf8c:	eb008d12 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    switch(fmt_params.fattype) {                                      
   1cf90:	e5dd3252 	ldrb	r3, [sp, #594]	; 0x252                       <== NOT EXECUTED
   1cf94:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
   1cf98:	0a00000a 	beq	1cfc8 <msdos_format+0xa70>                    <== NOT EXECUTED
   1cf9c:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
   1cfa0:	0a000010 	beq	1cfe8 <msdos_format+0xa90>                    <== NOT EXECUTED
   1cfa4:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   1cfa8:	1a00001e 	bne	1d028 <msdos_format+0xad0>                    <== NOT EXECUTED
    case FAT_FAT12:                                                   
      /* LSBits of FAT entry 0: media_type */                         
      FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));                
   1cfac:	e5dd3251 	ldrb	r3, [sp, #593]	; 0x251                       <== NOT EXECUTED
   1cfb0:	e5cd3020 	strb	r3, [sp, #32]                                <== NOT EXECUTED
      /* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
      FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));          
   1cfb4:	e3e03070 	mvn	r3, #112	; 0x70                               <== NOT EXECUTED
   1cfb8:	e5cd3021 	strb	r3, [sp, #33]	; 0x21                         <== NOT EXECUTED
      /* MSBits of FAT entry 1: MSBits of EOC */                      
      FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));                   
   1cfbc:	e2833070 	add	r3, r3, #112	; 0x70                           <== NOT EXECUTED
   1cfc0:	e5cd3022 	strb	r3, [sp, #34]	; 0x22                         <== NOT EXECUTED
      break;                                                          
   1cfc4:	ea00001b 	b	1d038 <msdos_format+0xae0>                      <== NOT EXECUTED
                                                                      
    case FAT_FAT16:                                                   
      /* FAT entry 0: 0xff00|media_type */                            
      FAT_SET_VAL16(tmp_sec,0,0xff00|fmt_params.media_code);          
   1cfc8:	e5dd2251 	ldrb	r2, [sp, #593]	; 0x251                       <== NOT EXECUTED
   1cfcc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   1cfd0:	e5cd2020 	strb	r2, [sp, #32]                                <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
   1cfd4:	e3e02007 	mvn	r2, #7                                        <== NOT EXECUTED
   1cfd8:	e5cd2022 	strb	r2, [sp, #34]	; 0x22                         <== NOT EXECUTED
   1cfdc:	e5cd3023 	strb	r3, [sp, #35]	; 0x23                         <== NOT EXECUTED
      FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));                   
      break;                                                          
                                                                      
    case FAT_FAT16:                                                   
      /* FAT entry 0: 0xff00|media_type */                            
      FAT_SET_VAL16(tmp_sec,0,0xff00|fmt_params.media_code);          
   1cfe0:	e5cd3021 	strb	r3, [sp, #33]	; 0x21                         <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
      break;                                                          
   1cfe4:	ea000013 	b	1d038 <msdos_format+0xae0>                      <== NOT EXECUTED
                                                                      
    case FAT_FAT32:                                                   
      /* FAT entry 0: 0xffffff00|media_type */                        
      FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);      
   1cfe8:	e5dd2251 	ldrb	r2, [sp, #593]	; 0x251                       <== NOT EXECUTED
   1cfec:	e1e02c02 	mvn	r2, r2, lsl #24                               <== NOT EXECUTED
   1cff0:	e1e02c22 	mvn	r2, r2, lsr #24                               <== NOT EXECUTED
   1cff4:	e1a01c22 	lsr	r1, r2, #24                                   <== NOT EXECUTED
   1cff8:	e5cd1021 	strb	r1, [sp, #33]	; 0x21                         <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
   1cffc:	e3e01007 	mvn	r1, #7                                        <== NOT EXECUTED
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
      break;                                                          
                                                                      
    case FAT_FAT32:                                                   
      /* FAT entry 0: 0xffffff00|media_type */                        
      FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);      
   1d000:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
   1d004:	e5cd1024 	strb	r1, [sp, #36]	; 0x24                         <== NOT EXECUTED
   1d008:	e2811017 	add	r1, r1, #23                                   <== NOT EXECUTED
   1d00c:	e5cd3026 	strb	r3, [sp, #38]	; 0x26                         <== NOT EXECUTED
   1d010:	e5cd1027 	strb	r1, [sp, #39]	; 0x27                         <== NOT EXECUTED
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
      break;                                                          
                                                                      
    case FAT_FAT32:                                                   
      /* FAT entry 0: 0xffffff00|media_type */                        
      FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);      
   1d014:	e5cd2020 	strb	r2, [sp, #32]                                <== NOT EXECUTED
   1d018:	e5cd3022 	strb	r3, [sp, #34]	; 0x22                         <== NOT EXECUTED
   1d01c:	e5cd3023 	strb	r3, [sp, #35]	; 0x23                         <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
   1d020:	e5cd3025 	strb	r3, [sp, #37]	; 0x25                         <== NOT EXECUTED
      break;                                                          
   1d024:	ea000003 	b	1d038 <msdos_format+0xae0>                      <== NOT EXECUTED
                                                                      
    default:                                                          
      ret_val = -1;                                                   
      errno = EINVAL;                                                 
   1d028:	eb007fb4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d02c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1d030:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1d034:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
    }                                                                 
    if (fmt_params.fattype == FAT_FAT32) {                            
   1d038:	e5dd3252 	ldrb	r3, [sp, #594]	; 0x252                       <== NOT EXECUTED
   1d03c:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
   1d040:	1a000006 	bne	1d060 <msdos_format+0xb08>                    <== NOT EXECUTED
      /*                                                              
       * only first valid cluster (cluster number 2) belongs          
       * to root directory, and is end of chain                       
       * mark this in every copy of the FAT                           
       */                                                             
      FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);                         
   1d044:	e3e02007 	mvn	r2, #7                                        <== NOT EXECUTED
   1d048:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   1d04c:	e5cd2028 	strb	r2, [sp, #40]	; 0x28                         <== NOT EXECUTED
   1d050:	e2822017 	add	r2, r2, #23                                   <== NOT EXECUTED
   1d054:	e5cd302a 	strb	r3, [sp, #42]	; 0x2a                         <== NOT EXECUTED
   1d058:	e5cd202b 	strb	r2, [sp, #43]	; 0x2b                         <== NOT EXECUTED
   1d05c:	e5cd3029 	strb	r3, [sp, #41]	; 0x29                         <== NOT EXECUTED
   1d060:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    }                                                                 
    for (i = 0;                                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
	 i++) {                                                              
      ret_val = msdos_format_write_sec                                
   1d064:	e28d8020 	add	r8, sp, #32                                   <== NOT EXECUTED
   1d068:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1d06c:	ea000007 	b	1d090 <msdos_format+0xb38>                      <== NOT EXECUTED
   1d070:	e59d3228 	ldr	r3, [sp, #552]	; 0x228                        <== NOT EXECUTED
   1d074:	e59d1230 	ldr	r1, [sp, #560]	; 0x230                        <== NOT EXECUTED
   1d078:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d07c:	e0213194 	mla	r1, r4, r1, r3                                <== NOT EXECUTED
   1d080:	e59d2220 	ldr	r2, [sp, #544]	; 0x220                        <== NOT EXECUTED
   1d084:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   1d088:	ebfffcd2 	bl	1c3d8 <msdos_format_write_sec>                 <== NOT EXECUTED
       */                                                             
      FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);                         
    }                                                                 
    for (i = 0;                                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
	 i++) {                                                              
   1d08c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
       * to root directory, and is end of chain                       
       * mark this in every copy of the FAT                           
       */                                                             
      FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);                         
    }                                                                 
    for (i = 0;                                                       
   1d090:	e5dd2250 	ldrb	r2, [sp, #592]	; 0x250                       <== NOT EXECUTED
   1d094:	e2703001 	rsbs	r3, r0, #1                                   <== NOT EXECUTED
   1d098:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
   1d09c:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
   1d0a0:	a3a03000 	movge	r3, #0                                      <== NOT EXECUTED
   1d0a4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1d0a8:	1afffff0 	bne	1d070 <msdos_format+0xb18>                    <== NOT EXECUTED
   1d0ac:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  /*                                                                  
   * cleanup:                                                         
   * sync and unlock disk                                             
   * free any data structures (not needed now)                        
   */                                                                 
  if (fd != -1) {                                                     
   1d0b0:	e3750001 	cmn	r5, #1                                        <== NOT EXECUTED
    close(fd);                                                        
   1d0b4:	11a00005 	movne	r0, r5                                      <== NOT EXECUTED
   1d0b8:	1bffa85d 	blne	7234 <close>                                 <== NOT EXECUTED
  }                                                                   
  if (dd != NULL) {                                                   
   1d0bc:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    rtems_disk_release(dd);                                           
   1d0c0:	11a00006 	movne	r0, r6                                      <== NOT EXECUTED
   1d0c4:	1bffa4f0 	blne	648c <rtems_disk_release>                    <== NOT EXECUTED
  }                                                                   
  return ret_val;                                                     
}                                                                     
   1d0c8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1d0cc:	e28ddfb1 	add	sp, sp, #708	; 0x2c4                          <== NOT EXECUTED
   1d0d0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
                                                                      
  /* check that  device is registered as block device and lock it */  
  if (ret_val == 0) {                                                 
    dd = rtems_disk_obtain(stat_buf.st_rdev);                         
   1d0d4:	e28d1fa2 	add	r1, sp, #648	; 0x288                          <== NOT EXECUTED
   1d0d8:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   1d0dc:	ebffa46e 	bl	629c <rtems_disk_obtain>                       <== NOT EXECUTED
    if (dd == NULL) {                                                 
   1d0e0:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1d0e4:	0afffd38 	beq	1c5cc <msdos_format+0x74>                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   * open device for writing                                          
   */                                                                 
  if (ret_val == 0) {                                                 
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1d0e8:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1d0ec:	e59f20fc 	ldr	r2, [pc, #252]	; 1d1f0 <msdos_format+0xc98>   <== NOT EXECUTED
   1d0f0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1d0f4:	ebfffca2 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                         "open device\n");                            
    fd = open(devname, O_RDWR);                                       
   1d0f8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d0fc:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1d100:	ebffad91 	bl	874c <open>                                    <== NOT EXECUTED
    if (fd == -1)                                                     
   1d104:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
   * open device for writing                                          
   */                                                                 
  if (ret_val == 0) {                                                 
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
                         "open device\n");                            
    fd = open(devname, O_RDWR);                                       
   1d108:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    if (fd == -1)                                                     
   1d10c:	01a07000 	moveq	r7, r0                                      <== NOT EXECUTED
   1d110:	0afffd31 	beq	1c5dc <msdos_format+0x84>                     <== NOT EXECUTED
  uint32_t fatdata_sect_cnt;                                          
  uint32_t onebit;                                                    
  uint32_t sectors_per_cluster_adj = 0;                               
  uint64_t total_size = 0;                                            
                                                                      
  memset(fmt_params,0,sizeof(*fmt_params));                           
   1d114:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1d118:	e3a02050 	mov	r2, #80	; 0x50                                <== NOT EXECUTED
   1d11c:	e28d0e22 	add	r0, sp, #544	; 0x220                          <== NOT EXECUTED
   1d120:	eb008cad 	bl	403dc <memset>                                 <== NOT EXECUTED
  /*                                                                  
   * this one is fixed in this implementation.                        
   * At least one thing we don't have to magically guess...           
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->bytes_per_sector = dd->block_size;                    
   1d124:	e5963020 	ldr	r3, [r6, #32]                                 <== NOT EXECUTED
   1d128:	e58d3220 	str	r3, [sp, #544]	; 0x220                        <== NOT EXECUTED
    fmt_params->totl_sector_cnt  = dd->size;                          
   1d12c:	e596c01c 	ldr	ip, [r6, #28]                                 <== NOT EXECUTED
    total_size = dd->block_size * dd->size;                           
   1d130:	e0070c93 	mul	r7, r3, ip                                    <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1d134:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   * At least one thing we don't have to magically guess...           
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->bytes_per_sector = dd->block_size;                    
    fmt_params->totl_sector_cnt  = dd->size;                          
    total_size = dd->block_size * dd->size;                           
   1d138:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1d13c:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1d140:	e59f20ac 	ldr	r2, [pc, #172]	; 1d1f4 <msdos_format+0xc9c>   <== NOT EXECUTED
   1d144:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   * this one is fixed in this implementation.                        
   * At least one thing we don't have to magically guess...           
   */                                                                 
  if (ret_val == 0) {                                                 
    fmt_params->bytes_per_sector = dd->block_size;                    
    fmt_params->totl_sector_cnt  = dd->size;                          
   1d148:	e58dc224 	str	ip, [sp, #548]	; 0x224                        <== NOT EXECUTED
    total_size = dd->block_size * dd->size;                           
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
   1d14c:	e98d0180 	stmib	sp, {r7, r8}                                <== NOT EXECUTED
   1d150:	ebfffc8b 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
   1d154:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1d158:	1afffd21 	bne	1c5e4 <msdos_format+0x8c>                     <== NOT EXECUTED
   1d15c:	eafffd23 	b	1c5f0 <msdos_format+0x98>                       <== NOT EXECUTED
   1d160:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
   1d164:	eafffe55 	b	1cac0 <msdos_format+0x568>                      <== NOT EXECUTED
    ret_val = msdos_format_read_sec(fd,                               
                                    0,                                
                                    fmt_params.bytes_per_sector,      
                                    tmp_sec);                         
    if (ret_val == 0) {                                               
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
   1d168:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1d16c:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1d170:	e59f2080 	ldr	r2, [pc, #128]	; 1d1f8 <msdos_format+0xca0>   <== NOT EXECUTED
   1d174:	ebfffc82 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
{                                                                     
  uint32_t  total_sectors_num16 = 0;                                  
  uint32_t  total_sectors_num32 = 0;                                  
                                                                      
  /* store total sector count in either 16 or 32 bit field in mbr */  
  if (fmt_params->totl_sector_cnt < 0x10000) {                        
   1d178:	e59d8224 	ldr	r8, [sp, #548]	; 0x224                        <== NOT EXECUTED
   1d17c:	e3580801 	cmp	r8, #65536	; 0x10000                          <== NOT EXECUTED
   1d180:	31a0b008 	movcc	fp, r8                                      <== NOT EXECUTED
   1d184:	33a08000 	movcc	r8, #0                                      <== NOT EXECUTED
   1d188:	3afffe75 	bcc	1cb64 <msdos_format+0x60c>                    <== NOT EXECUTED
   1d18c:	eafffe73 	b	1cb60 <msdos_format+0x608>                      <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
   1d190:	e59d124c 	ldr	r1, [sp, #588]	; 0x24c                        <== NOT EXECUTED
      ret_val = msdos_format_gen_fsinfo(tmp_sec);                     
  }                                                                   
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
   1d194:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   1d198:	0affff46 	beq	1ceb8 <msdos_format+0x960>                    <== NOT EXECUTED
   1d19c:	eaffff3f 	b	1cea0 <msdos_format+0x948>                      <== NOT EXECUTED
                                                                      

0001c428 <msdos_format_fill_sectors>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
   1c428:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
   1c42c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
   1c430:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
 )                                                                    
/*-------------------------------------------------------------------------*\
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
   1c434:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
   1c438:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   1c43c:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
   1c440:	e5dd4030 	ldrb	r4, [sp, #48]	; 0x30                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
   1c444:	ebffae41 	bl	7d50 <malloc>                                  <== NOT EXECUTED
    if (fill_buffer == NULL) {                                        
   1c448:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   1c44c:	1a000004 	bne	1c464 <msdos_format_fill_sectors+0x3c>        <== NOT EXECUTED
      errno = ENOMEM;                                                 
   1c450:	eb0082aa 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c454:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   1c458:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c45c:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   1c460:	ea000003 	b	1c474 <msdos_format_fill_sectors+0x4c>          <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
    else {                                                            
      memset(fill_buffer,fill_byte,sector_size);                      
   1c464:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1c468:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   1c46c:	eb008fda 	bl	403dc <memset>                                 <== NOT EXECUTED
   1c470:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
   1c474:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1c478:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1c47c:	e59f20c4 	ldr	r2, [pc, #196]	; 1c548 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
   1c480:	ebffffbf 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
   1c484:	e3a03064 	mov	r3, #100	; 0x64                               <== NOT EXECUTED
   1c488:	e0080a93 	mul	r8, r3, sl                                    <== NOT EXECUTED
   1c48c:	e1a0900a 	mov	r9, sl                                        <== NOT EXECUTED
   1c490:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
   1c494:	ea000014 	b	1c4ec <msdos_format_fill_sectors+0xc4>          <== NOT EXECUTED
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
   1c498:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
   1c49c:	eb00e255 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
    if (percent != last_percent) {                                    
   1c4a0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   1c4a4:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
   1c4a8:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    if (percent != last_percent) {                                    
   1c4ac:	0a000004 	beq	1c4c4 <msdos_format_fill_sectors+0x9c>        <== NOT EXECUTED
      if ((percent & 1) == 0)                                         
   1c4b0:	e3100001 	tst	r0, #1                                        <== NOT EXECUTED
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
   1c4b4:	01a00006 	moveq	r0, r6                                      <== NOT EXECUTED
   1c4b8:	03a01002 	moveq	r1, #2                                      <== NOT EXECUTED
   1c4bc:	059f2088 	ldreq	r2, [pc, #136]	; 1c54c <msdos_format_fill_sectors+0x124><== NOT EXECUTED
   1c4c0:	0bffffaf 	bleq	1c384 <msdos_format_printf>                  <== NOT EXECUTED
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
   1c4c4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1c4c8:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
   1c4cc:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
   1c4d0:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   1c4d4:	ebffffbf 	bl	1c3d8 <msdos_format_write_sec>                 <== NOT EXECUTED
    start_sector++;                                                   
   1c4d8:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    if (percent != last_percent) {                                    
      if ((percent & 1) == 0)                                         
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
   1c4dc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    start_sector++;                                                   
    sector_cnt--;                                                     
   1c4e0:	e2499001 	sub	r9, r9, #1                                    <== NOT EXECUTED
   1c4e4:	e2488064 	sub	r8, r8, #100	; 0x64                           <== NOT EXECUTED
   1c4e8:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
   1c4ec:	e2592000 	subs	r2, r9, #0                                   <== NOT EXECUTED
   1c4f0:	13a02001 	movne	r2, #1                                      <== NOT EXECUTED
   1c4f4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1c4f8:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
   1c4fc:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
   1c500:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1c504:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
   1c508:	1affffe2 	bne	1c498 <msdos_format_fill_sectors+0x70>        <== NOT EXECUTED
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
    start_sector++;                                                   
    sector_cnt--;                                                     
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");    
   1c50c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1c510:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   1c514:	e59f2034 	ldr	r2, [pc, #52]	; 1c550 <msdos_format_fill_sectors+0x128><== NOT EXECUTED
   1c518:	ebffff99 	bl	1c384 <msdos_format_printf>                    <== NOT EXECUTED
                                                                      
  if (ret_val)                                                        
   1c51c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,           
   1c520:	11a00006 	movne	r0, r6                                      <== NOT EXECUTED
   1c524:	11a03005 	movne	r3, r5                                      <== NOT EXECUTED
   1c528:	13a01001 	movne	r1, #1                                      <== NOT EXECUTED
   1c52c:	159f2020 	ldrne	r2, [pc, #32]	; 1c554 <msdos_format_fill_sectors+0x12c><== NOT EXECUTED
   1c530:	1bffff93 	blne	1c384 <msdos_format_printf>                  <== NOT EXECUTED
                         "filling error on sector: %d\n", start_sector);
                                                                      
  /*                                                                  
   * cleanup                                                          
   */                                                                 
  if (fill_buffer != NULL) {                                          
   1c534:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
    free(fill_buffer);                                                
   1c538:	11a0000b 	movne	r0, fp                                      <== NOT EXECUTED
   1c53c:	1bffac5c 	blne	76b4 <free>                                  <== NOT EXECUTED
    fill_buffer = NULL;                                               
  }                                                                   
  return ret_val;                                                     
}                                                                     
   1c540:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1c544:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
                                                                      

0001c384 <msdos_format_printf>: */ static void msdos_format_printf (const msdos_format_request_param_t *rqdata, int info_level, const char *format, ...) {
   1c384:	e92d000c 	push	{r2, r3}                                     <== NOT EXECUTED
   1c388:	e92d4011 	push	{r0, r4, lr}                                 <== NOT EXECUTED
  va_list args;                                                       
  va_start (args, format);                                            
  if (rqdata != NULL && rqdata->info_level >= info_level)             
   1c38c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
msdos_format_printf (const msdos_format_request_param_t *rqdata,      
                     int                                 info_level,  
                     const char                         *format, ...) 
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
   1c390:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
   1c394:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
  if (rqdata != NULL && rqdata->info_level >= info_level)             
   1c398:	0a00000a 	beq	1c3c8 <msdos_format_printf+0x44>              <== NOT EXECUTED
   1c39c:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
   1c3a0:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   1c3a4:	ba000007 	blt	1c3c8 <msdos_format_printf+0x44>              <== NOT EXECUTED
  {                                                                   
    vfprintf (stdout, format, args);                                  
   1c3a8:	e59f4024 	ldr	r4, [pc, #36]	; 1c3d4 <msdos_format_printf+0x50><== NOT EXECUTED
   1c3ac:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   1c3b0:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
   1c3b4:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
   1c3b8:	eb00bded 	bl	4bb74 <vfprintf>                               <== NOT EXECUTED
    fflush (stdout);                                                  
   1c3bc:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   1c3c0:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
   1c3c4:	eb0083c0 	bl	3d2cc <fflush>                                 <== NOT EXECUTED
  }                                                                   
  va_end (args);                                                      
}                                                                     
   1c3c8:	e8bd4018 	pop	{r3, r4, lr}                                  <== NOT EXECUTED
   1c3cc:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
   1c3d0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001c3d8 <msdos_format_write_sec>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
   1c3d8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
   1c3dc:	e0876192 	umull	r6, r7, r2, r1                              <== NOT EXECUTED
 )                                                                    
/*-------------------------------------------------------------------------*\
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
   1c3e0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
   1c3e4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
 )                                                                    
/*-------------------------------------------------------------------------*\
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
   1c3e8:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
   1c3ec:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1c3f0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
 )                                                                    
/*-------------------------------------------------------------------------*\
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
   1c3f4:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
   1c3f8:	eb0026d1 	bl	25f44 <lseek>                                  <== NOT EXECUTED
   1c3fc:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   1c400:	ba000006 	blt	1c420 <msdos_format_write_sec+0x48>           <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > write(fd,buffer,sector_size)) {                           
   1c404:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1c408:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1c40c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   1c410:	ebffbad8 	bl	af78 <write>                                   <== NOT EXECUTED
   1c414:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1c418:	a3a00000 	movge	r0, #0                                      <== NOT EXECUTED
   1c41c:	a8bd80f0 	popge	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
   1c420:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
   1c424:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00031d48 <msdos_free_node_info>: int msdos_free_node_info(rtems_filesystem_location_info_t *pathloc) { int rc = RC_OK; rtems_status_code sc = RTEMS_SUCCESSFUL; msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
   31d48:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
 *     RC_OK on success, or -1 code if error occured                  
 *                                                                    
 */                                                                   
int                                                                   
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)       
{                                                                     
   31d4c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
   31d50:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31d54:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *     RC_OK on success, or -1 code if error occured                  
 *                                                                    
 */                                                                   
int                                                                   
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)       
{                                                                     
   31d58:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;          
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   31d5c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   31d60:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31d64:	ebff66d5 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   31d68:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   31d6c:	0a000004 	beq	31d84 <msdos_free_node_info+0x3c>             <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   31d70:	eb002c62 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   31d74:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   31d78:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   31d7c:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   31d80:	ea000005 	b	31d9c <msdos_free_node_info+0x54>               <== NOT EXECUTED
                                                                      
    rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);     
   31d84:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
   31d88:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
   31d8c:	ebffc149 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   31d90:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   31d94:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
   31d98:	ebff670e 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   31d9c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   31da0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00032f38 <msdos_get_dotdot_dir_info_cluster_num_and_offset>: rtems_filesystem_mount_table_entry_t *mt_entry, uint32_t cln, fat_dir_pos_t *dir_pos, char *dir_entry ) {
   32f38:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   32f3c:	e24dd058 	sub	sp, sp, #88	; 0x58                            <== NOT EXECUTED
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    fat_file_fd_t   *fat_fd = NULL;                                   
   32f40:	e28dc058 	add	ip, sp, #88	; 0x58                            <== NOT EXECUTED
   32f44:	e3a0e000 	mov	lr, #0                                        <== NOT EXECUTED
   32f48:	e52ce004 	str	lr, [ip, #-4]!                                <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    fat_dir_pos_t                        *dir_pos,                    
    char                                 *dir_entry                   
    )                                                                 
{                                                                     
   32f4c:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   32f50:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
    uint32_t         cl4find = 0;                                     
                                                                      
    /*                                                                
     * open fat-file corresponded to ".."                             
     */                                                               
    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);                   
   32f54:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
   32f58:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln,                        
    fat_dir_pos_t                        *dir_pos,                    
    char                                 *dir_entry                   
    )                                                                 
{                                                                     
   32f5c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   32f60:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   32f64:	e5909034 	ldr	r9, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t         cl4find = 0;                                     
                                                                      
    /*                                                                
     * open fat-file corresponded to ".."                             
     */                                                               
    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);                   
   32f68:	ebffbcfb 	bl	2235c <fat_file_open>                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   32f6c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   32f70:	1a00006f 	bne	33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
   32f74:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
   32f78:	e3a03602 	mov	r3, #2097152	; 0x200000                       <== NOT EXECUTED
    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);                   
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   32f7c:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
   32f80:	e5814034 	str	r4, [r1, #52]	; 0x34                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
   32f84:	e5813014 	str	r3, [r1, #20]                                 <== NOT EXECUTED
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
   32f88:	e5817038 	str	r7, [r1, #56]	; 0x38                          <== NOT EXECUTED
     */                                                               
    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);                   
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
   32f8c:	e581701c 	str	r7, [r1, #28]                                 <== NOT EXECUTED
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   32f90:	e5818010 	str	r8, [r1, #16]                                 <== NOT EXECUTED
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
                                                                      
    rc = fat_file_size(mt_entry, fat_fd);                             
   32f94:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   32f98:	ebffba3e 	bl	21898 <fat_file_size>                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   32f9c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   32fa0:	1a00005b 	bne	33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== NOT EXECUTED
        fat_file_close(mt_entry, fat_fd);                             
        return rc;                                                    
    }                                                                 
                                                                      
    /* find "." node in opened directory */                           
    memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);           
   32fa4:	e28da034 	add	sl, sp, #52	; 0x34                            <== NOT EXECUTED
   32fa8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   32fac:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   32fb0:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   32fb4:	eb003508 	bl	403dc <memset>                                 <== NOT EXECUTED
    msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);      
   32fb8:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   32fbc:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   32fc0:	e3a0300b 	mov	r3, #11                                       <== NOT EXECUTED
   32fc4:	e59f0174 	ldr	r0, [pc, #372]	; 33140 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
   32fc8:	ebffff74 	bl	32da0 <msdos_long_to_short>                    <== NOT EXECUTED
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1, 
   32fcc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   32fd0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   32fd4:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
   32fd8:	e59f3160 	ldr	r3, [pc, #352]	; 33140 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
   32fdc:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
   32fe0:	e58d8004 	str	r8, [sp, #4]                                  <== NOT EXECUTED
   32fe4:	e58d6008 	str	r6, [sp, #8]                                  <== NOT EXECUTED
   32fe8:	e58da00c 	str	sl, [sp, #12]                                 <== NOT EXECUTED
   32fec:	ebfffbd6 	bl	31f4c <msdos_find_name_in_fat_file>            <== NOT EXECUTED
                                     MSDOS_NAME_SHORT, dir_pos, dot_node);
                                                                      
    if (rc != RC_OK)                                                  
   32ff0:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   32ff4:	1a000046 	bne	33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== NOT EXECUTED
        fat_file_close(mt_entry, fat_fd);                             
        return rc;                                                    
    }                                                                 
                                                                      
    /* find ".." node in opened directory */                          
    memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);        
   32ff8:	e28d7014 	add	r7, sp, #20                                   <== NOT EXECUTED
   32ffc:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33000:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   33004:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   33008:	eb0034f3 	bl	403dc <memset>                                 <== NOT EXECUTED
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
   3300c:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
   33010:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   33014:	e3a0300b 	mov	r3, #11                                       <== NOT EXECUTED
   33018:	e59f0124 	ldr	r0, [pc, #292]	; 33144 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NOT EXECUTED
   3301c:	ebffff5f 	bl	32da0 <msdos_long_to_short>                    <== NOT EXECUTED
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
   33020:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   33024:	e3a0c002 	mov	ip, #2                                        <== NOT EXECUTED
   33028:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3302c:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
   33030:	e59f310c 	ldr	r3, [pc, #268]	; 33144 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NOT EXECUTED
   33034:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   33038:	e58d8004 	str	r8, [sp, #4]                                  <== NOT EXECUTED
   3303c:	e58d6008 	str	r6, [sp, #8]                                  <== NOT EXECUTED
   33040:	e58d700c 	str	r7, [sp, #12]                                 <== NOT EXECUTED
   33044:	ebfffbc0 	bl	31f4c <msdos_find_name_in_fat_file>            <== NOT EXECUTED
                                     MSDOS_NAME_SHORT, dir_pos,       
                                     dotdot_node);                    
                                                                      
    if (rc != RC_OK)                                                  
   33048:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   3304c:	1a000030 	bne	33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== NOT EXECUTED
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
                                                                      
    /* close fat-file corresponded to ".." directory */               
    rc = fat_file_close(mt_entry, fat_fd);                            
   33050:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33054:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
    {                                                                 
        fat_file_close(mt_entry, fat_fd);                             
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
   33058:	e1dab1b4 	ldrh	fp, [sl, #20]                                <== NOT EXECUTED
   3305c:	e1daa1ba 	ldrh	sl, [sl, #26]                                <== NOT EXECUTED
                                                                      
    /* close fat-file corresponded to ".." directory */               
    rc = fat_file_close(mt_entry, fat_fd);                            
   33060:	ebffbc94 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
    if ( rc != RC_OK )                                                
   33064:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   33068:	1a000031 	bne	33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
        return rc;                                                    
                                                                      
    if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)               
   3306c:	e1d731ba 	ldrh	r3, [r7, #26]                                <== NOT EXECUTED
   33070:	e1d721b4 	ldrh	r2, [r7, #20]                                <== NOT EXECUTED
   33074:	e1932802 	orrs	r2, r3, r2, lsl #16                          <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   33078:	03e03000 	mvneq	r3, #0                                      <== NOT EXECUTED
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
   3307c:	05862004 	streq	r2, [r6, #4]                                <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
   33080:	0586300c 	streq	r3, [r6, #12]                               <== NOT EXECUTED
        /*                                                            
         * we handle root dir for all FAT types in the same way with the
         * ordinary directories ( through fat_file_* calls )          
         */                                                           
        fat_dir_pos_init(dir_pos);                                    
        dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;                 
   33084:	05868000 	streq	r8, [r6]                                    <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   33088:	05863008 	streq	r3, [r6, #8]                                <== NOT EXECUTED
    }                                                                 
                                                                      
    /* open fat-file corresponded to second ".." */                   
    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);                   
   3308c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33090:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   33094:	e28d2054 	add	r2, sp, #84	; 0x54                            <== NOT EXECUTED
   33098:	ebffbcaf 	bl	2235c <fat_file_open>                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   3309c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   330a0:	1a000023 	bne	33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
        return rc;                                                    
                                                                      
    if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)                
   330a4:	e1d731ba 	ldrh	r3, [r7, #26]                                <== NOT EXECUTED
   330a8:	e1d721b4 	ldrh	r2, [r7, #20]                                <== NOT EXECUTED
   330ac:	e1932802 	orrs	r2, r3, r2, lsl #16                          <== NOT EXECUTED
        fat_fd->cln = fs_info->fat.vol.rdir_cl;                       
   330b0:	05992038 	ldreq	r2, [r9, #56]	; 0x38                        <== NOT EXECUTED
   330b4:	e59d3054 	ldr	r3, [sp, #84]	; 0x54                          <== NOT EXECUTED
    else                                                              
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);         
                                                                      
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   330b8:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
        return rc;                                                    
                                                                      
    if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)                
        fat_fd->cln = fs_info->fat.vol.rdir_cl;                       
    else                                                              
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);         
   330bc:	e583201c 	str	r2, [r3, #28]                                 <== NOT EXECUTED
                                                                      
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   330c0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
   330c4:	e591301c 	ldr	r3, [r1, #28]                                 <== NOT EXECUTED
    if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)                
        fat_fd->cln = fs_info->fat.vol.rdir_cl;                       
    else                                                              
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);         
                                                                      
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   330c8:	e5812010 	str	r2, [r1, #16]                                 <== NOT EXECUTED
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
   330cc:	e3a02602 	mov	r2, #2097152	; 0x200000                       <== NOT EXECUTED
   330d0:	e5812014 	str	r2, [r1, #20]                                 <== NOT EXECUTED
                                                                      
    fat_fd->map.file_cln = 0;                                         
   330d4:	e2422602 	sub	r2, r2, #2097152	; 0x200000                   <== NOT EXECUTED
   330d8:	e5812034 	str	r2, [r1, #52]	; 0x34                          <== NOT EXECUTED
    fat_fd->map.disk_cln = fat_fd->cln;                               
   330dc:	e5813038 	str	r3, [r1, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    rc = fat_file_size(mt_entry, fat_fd);                             
   330e0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   330e4:	ebffb9eb 	bl	21898 <fat_file_size>                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   330e8:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   330ec:	1a000008 	bne	33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== NOT EXECUTED
        fat_file_close(mt_entry, fat_fd);                             
        return rc;                                                    
    }                                                                 
                                                                      
    /* in this directory find slot with specified cluster num */      
    rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
   330f0:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
   330f4:	e18a280b 	orr	r2, sl, fp, lsl #16                           <== NOT EXECUTED
   330f8:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   330fc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33100:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
   33104:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   33108:	ebfffb38 	bl	31df0 <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
   3310c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   33110:	0a000003 	beq	33124 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ec><== NOT EXECUTED
    {                                                                 
        fat_file_close(mt_entry, fat_fd);                             
   33114:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33118:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
   3311c:	ebffbc65 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
        return rc;                                                    
   33120:	ea000003 	b	33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
    }                                                                 
    rc = fat_file_close(mt_entry, fat_fd);                            
   33124:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33128:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          <== NOT EXECUTED
   3312c:	ebffbc61 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   33130:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   33134:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   33138:	e28dd058 	add	sp, sp, #88	; 0x58                            <== NOT EXECUTED
   3313c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00033148 <msdos_get_name_node>: int name_len, msdos_name_type_t name_type, fat_dir_pos_t *dir_pos, char *name_dir_entry ) {
   33148:	e92d45ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
    int              rc = RC_OK;                                      
    fat_file_fd_t   *fat_fd = parent_loc->node_access;                
    uint32_t         dotdot_cln = 0;                                  
                                                                      
    /* find name in fat-file which corresponds to the directory */    
    rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,    
   3314c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    int                               name_len,                       
    msdos_name_type_t                 name_type,                      
    fat_dir_pos_t                    *dir_pos,                        
    char                             *name_dir_entry                  
    )                                                                 
{                                                                     
   33150:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   33154:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
   33158:	e20170ff 	and	r7, r1, #255	; 0xff                           <== NOT EXECUTED
   3315c:	e28d4030 	add	r4, sp, #48	; 0x30                            <== NOT EXECUTED
   33160:	e8940030 	ldm	r4, {r4, r5}                                  <== NOT EXECUTED
    int              rc = RC_OK;                                      
    fat_file_fd_t   *fat_fd = parent_loc->node_access;                
    uint32_t         dotdot_cln = 0;                                  
                                                                      
    /* find name in fat-file which corresponds to the directory */    
    rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,    
   33164:	e59dc02c 	ldr	ip, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   33168:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
   3316c:	e5961000 	ldr	r1, [r6]                                      <== NOT EXECUTED
   33170:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   33174:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   33178:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   3317c:	e58d4008 	str	r4, [sp, #8]                                  <== NOT EXECUTED
   33180:	e58d500c 	str	r5, [sp, #12]                                 <== NOT EXECUTED
   33184:	ebfffb70 	bl	31f4c <msdos_find_name_in_fat_file>            <== NOT EXECUTED
                                     create_node, name, name_len, name_type,
                                     dir_pos, name_dir_entry);        
    if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))            
   33188:	e59f308c 	ldr	r3, [pc, #140]	; 3321c <msdos_get_name_node+0xd4><== NOT EXECUTED
   3318c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
   33190:	13500000 	cmpne	r0, #0                                      <== NOT EXECUTED
    int              rc = RC_OK;                                      
    fat_file_fd_t   *fat_fd = parent_loc->node_access;                
    uint32_t         dotdot_cln = 0;                                  
                                                                      
    /* find name in fat-file which corresponds to the directory */    
    rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,    
   33194:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
                                     create_node, name, name_len, name_type,
                                     dir_pos, name_dir_entry);        
    if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))            
   33198:	1a00001c 	bne	33210 <msdos_get_name_node+0xc8>              <== NOT EXECUTED
        return rc;                                                    
                                                                      
    if (!create_node)                                                 
   3319c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   331a0:	1a00001a 	bne	33210 <msdos_get_name_node+0xc8>              <== NOT EXECUTED
    {                                                                 
        /* if we search for valid name and name not found -> return */
        if (rc == MSDOS_NAME_NOT_FOUND_ERR)                           
   331a4:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
   331a8:	0a000018 	beq	33210 <msdos_get_name_node+0xc8>              <== NOT EXECUTED
         * if we have deal with ".." - it is a special case :(((      
         *                                                            
         * Really, we should return cluster num and offset not of ".." slot, but
         * slot which correspondes to real directory name.            
         */                                                           
        if (rc == RC_OK)                                              
   331ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   331b0:	1a000016 	bne	33210 <msdos_get_name_node+0xc8>              <== NOT EXECUTED
        {                                                             
            if (strncmp(name, "..", 2) == 0)                          
   331b4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   331b8:	e59f1060 	ldr	r1, [pc, #96]	; 33220 <msdos_get_name_node+0xd8><== NOT EXECUTED
   331bc:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
   331c0:	eb004295 	bl	43c1c <strncmp>                                <== NOT EXECUTED
   331c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   331c8:	1a000010 	bne	33210 <msdos_get_name_node+0xc8>              <== NOT EXECUTED
            {                                                         
                dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
   331cc:	e1d511b4 	ldrh	r1, [r5, #20]                                <== NOT EXECUTED
   331d0:	e1d531ba 	ldrh	r3, [r5, #26]                                <== NOT EXECUTED
                                                                      
                /* are we right under root dir ? */                   
                if (dotdot_cln == 0)                                  
   331d4:	e1931801 	orrs	r1, r3, r1, lsl #16                          <== NOT EXECUTED
   331d8:	1a000006 	bne	331f8 <msdos_get_name_node+0xb0>              <== NOT EXECUTED
   331dc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
                    /*                                                
                     * we can relax about first_char field - it never should be
                     * used for root dir                              
                     */                                               
                    fat_dir_pos_init(dir_pos);                        
                    dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;     
   331e0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   331e4:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
   331e8:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
   331ec:	e584a004 	str	sl, [r4, #4]                                  <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   331f0:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
   331f4:	ea000005 	b	33210 <msdos_get_name_node+0xc8>                <== NOT EXECUTED
                }                                                     
                else                                                  
                {                                                     
                    rc =                                              
                        msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
   331f8:	e5960010 	ldr	r0, [r6, #16]                                 <== NOT EXECUTED
   331fc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   33200:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
   33204:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   33208:	e8bd45f0 	pop	{r4, r5, r6, r7, r8, sl, lr}                  <== NOT EXECUTED
                    dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;     
                }                                                     
                else                                                  
                {                                                     
                    rc =                                              
                        msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
   3320c:	eaffff49 	b	32f38 <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
   33210:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   33214:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   33218:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

00032cc0 <msdos_get_token>: msdos_token_types_t msdos_get_token(const char *path, int pathlen, const char **ret_token, int *ret_token_len) {
   32cc0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
    msdos_token_types_t type = MSDOS_NAME;                            
    int                 i = 0;                                        
                                                                      
    *ret_token = NULL;                                                
   32cc4:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
    *ret_token_len = 0;                                               
                                                                      
    if (pathlen == 0)                                                 
   32cc8:	e2518000 	subs	r8, r1, #0                                   <== NOT EXECUTED
msdos_token_types_t                                                   
msdos_get_token(const char  *path,                                    
                int          pathlen,                                 
                const char **ret_token,                               
                int         *ret_token_len)                           
{                                                                     
   32ccc:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   32cd0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
   32cd4:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
    msdos_token_types_t type = MSDOS_NAME;                            
    int                 i = 0;                                        
                                                                      
    *ret_token = NULL;                                                
   32cd8:	e5826000 	str	r6, [r2]                                      <== NOT EXECUTED
    *ret_token_len = 0;                                               
   32cdc:	e5836000 	str	r6, [r3]                                      <== NOT EXECUTED
                                                                      
    if (pathlen == 0)                                                 
   32ce0:	01a00008 	moveq	r0, r8                                      <== NOT EXECUTED
   32ce4:	1a000007 	bne	32d08 <msdos_get_token+0x48>                  <== NOT EXECUTED
   32ce8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    /*                                                                
     *  Check for a separator.                                        
     */                                                               
    while (!msdos_is_separator(path[i]) && (i < pathlen))             
    {                                                                 
        if ( !msdos_is_valid_name_char(path[i]) )                     
   32cec:	e7d70006 	ldrb	r0, [r7, r6]                                 <== NOT EXECUTED
   32cf0:	ebffffd7 	bl	32c54 <msdos_is_valid_name_char>               <== NOT EXECUTED
   32cf4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            return MSDOS_INVALID_TOKEN;                               
        ++i;                                                          
   32cf8:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
    /*                                                                
     *  Check for a separator.                                        
     */                                                               
    while (!msdos_is_separator(path[i]) && (i < pathlen))             
    {                                                                 
        if ( !msdos_is_valid_name_char(path[i]) )                     
   32cfc:	0a000025 	beq	32d98 <msdos_get_token+0xd8>                  <== NOT EXECUTED
            return MSDOS_INVALID_TOKEN;                               
        ++i;                                                          
        if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )                       
   32d00:	e3560f41 	cmp	r6, #260	; 0x104                              <== NOT EXECUTED
   32d04:	0a000023 	beq	32d98 <msdos_get_token+0xd8>                  <== NOT EXECUTED
        return MSDOS_NO_MORE_PATH;                                    
                                                                      
    /*                                                                
     *  Check for a separator.                                        
     */                                                               
    while (!msdos_is_separator(path[i]) && (i < pathlen))             
   32d08:	e7d70006 	ldrb	r0, [r7, r6]                                 <== NOT EXECUTED
   32d0c:	ebff589d 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   32d10:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32d14:	1a000001 	bne	32d20 <msdos_get_token+0x60>                  <== NOT EXECUTED
   32d18:	e1560008 	cmp	r6, r8                                        <== NOT EXECUTED
   32d1c:	bafffff2 	blt	32cec <msdos_get_token+0x2c>                  <== NOT EXECUTED
    *ret_token = path;                                                
                                                                      
    /*                                                                
     *  If it is just a separator then it is the current dir.         
     */                                                               
    if ( i == 0 )                                                     
   32d20:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
        ++i;                                                          
        if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )                       
            return MSDOS_INVALID_TOKEN;                               
    }                                                                 
                                                                      
    *ret_token = path;                                                
   32d24:	e5847000 	str	r7, [r4]                                      <== NOT EXECUTED
                                                                      
    /*                                                                
     *  If it is just a separator then it is the current dir.         
     */                                                               
    if ( i == 0 )                                                     
   32d28:	13a00003 	movne	r0, #3                                      <== NOT EXECUTED
   32d2c:	1a000003 	bne	32d40 <msdos_get_token+0x80>                  <== NOT EXECUTED
    {                                                                 
      if ( (*path != '\0') && pathlen )                               
   32d30:	e5d73000 	ldrb	r3, [r7]                                     <== NOT EXECUTED
   32d34:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   32d38:	13a06001 	movne	r6, #1                                      <== NOT EXECUTED
   32d3c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     *  If we copied something that was not a seperator see if        
     *  it was a special name.                                        
     */                                                               
    if ( type == MSDOS_NAME )                                         
   32d40:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     *  Set the token and token_len to the token start and length.    
     */                                                               
    *ret_token_len = i;                                               
   32d44:	e5856000 	str	r6, [r5]                                      <== NOT EXECUTED
                                                                      
    /*                                                                
     *  If we copied something that was not a seperator see if        
     *  it was a special name.                                        
     */                                                               
    if ( type == MSDOS_NAME )                                         
   32d48:	18bd81f0 	popne	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
    {                                                                 
        if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
   32d4c:	e3560002 	cmp	r6, #2                                        <== NOT EXECUTED
   32d50:	1a000008 	bne	32d78 <msdos_get_token+0xb8>                  <== NOT EXECUTED
   32d54:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   32d58:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
   32d5c:	e352002e 	cmp	r2, #46	; 0x2e                                <== NOT EXECUTED
   32d60:	18bd81f0 	popne	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
   32d64:	e5d30001 	ldrb	r0, [r3, #1]                                 <== NOT EXECUTED
   32d68:	e350002e 	cmp	r0, #46	; 0x2e                                <== NOT EXECUTED
   32d6c:	13a00003 	movne	r0, #3                                      <== NOT EXECUTED
   32d70:	03a00002 	moveq	r0, #2                                      <== NOT EXECUTED
   32d74:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
        {                                                             
            type = MSDOS_UP_DIR;                                      
            return type;                                              
        }                                                             
                                                                      
        if ((i == 1) && ((*ret_token)[0] == '.'))                     
   32d78:	e3560001 	cmp	r6, #1                                        <== NOT EXECUTED
   32d7c:	18bd81f0 	popne	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
   32d80:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   32d84:	e5d30000 	ldrb	r0, [r3]                                     <== NOT EXECUTED
   32d88:	e350002e 	cmp	r0, #46	; 0x2e                                <== NOT EXECUTED
   32d8c:	13a00003 	movne	r0, #3                                      <== NOT EXECUTED
   32d90:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
   32d94:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
   32d98:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
            return type;                                              
        }                                                             
    }                                                                 
                                                                      
    return type;                                                      
}                                                                     
   32d9c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0001d218 <msdos_initialize_support>: rtems_filesystem_mount_table_entry_t *temp_mt_entry, const rtems_filesystem_operations_table *op_table, const rtems_filesystem_file_handlers_r *file_handlers, const rtems_filesystem_file_handlers_r *directory_handlers ) {
   1d218:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = NULL;                                
    fat_file_fd_t     *fat_fd = NULL;                                 
   1d21c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t    *temp_mt_entry,           
    const rtems_filesystem_operations_table *op_table,                
    const rtems_filesystem_file_handlers_r  *file_handlers,           
    const rtems_filesystem_file_handlers_r  *directory_handlers       
    )                                                                 
{                                                                     
   1d220:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
   1d224:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   1d228:	e1a09001 	mov	r9, r1                                        <== NOT EXECUTED
    msdos_fs_info_t   *fs_info = NULL;                                
    fat_file_fd_t     *fat_fd = NULL;                                 
    fat_dir_pos_t      root_pos;                                      
    uint32_t           cl_buf_size;                                   
                                                                      
    fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));  
   1d22c:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
   1d230:	e3a0109c 	mov	r1, #156	; 0x9c                               <== NOT EXECUTED
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info = NULL;                                
    fat_file_fd_t     *fat_fd = NULL;                                 
   1d234:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t    *temp_mt_entry,           
    const rtems_filesystem_operations_table *op_table,                
    const rtems_filesystem_file_handlers_r  *file_handlers,           
    const rtems_filesystem_file_handlers_r  *directory_handlers       
    )                                                                 
{                                                                     
   1d238:	e1a0a002 	mov	sl, r2                                        <== NOT EXECUTED
   1d23c:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
    msdos_fs_info_t   *fs_info = NULL;                                
    fat_file_fd_t     *fat_fd = NULL;                                 
    fat_dir_pos_t      root_pos;                                      
    uint32_t           cl_buf_size;                                   
                                                                      
    fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));  
   1d240:	ebffa7ab 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if (!fs_info)                                                     
   1d244:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1d248:	0a00003d 	beq	1d344 <msdos_initialize_support+0x12c>        <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
                                                                      
    temp_mt_entry->fs_info = fs_info;                                 
   1d24c:	e5854034 	str	r4, [r5, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    rc = fat_init_volume_info(temp_mt_entry);                         
   1d250:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d254:	eb0016b7 	bl	22d38 <fat_init_volume_info>                   <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   1d258:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1d25c:	1a00000f 	bne	1d2a0 <msdos_initialize_support+0x88>         <== NOT EXECUTED
    /*                                                                
     * open fat-file which correspondes to  root directory            
     * (so inode number 0x00000010 is always used for root directory) 
     */                                                               
    fat_dir_pos_init(&root_pos);                                      
    root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;                     
   1d260:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   1d264:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   1d268:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   1d26c:	e5218014 	str	r8, [r1, #-20]!                               <== NOT EXECUTED
    {                                                                 
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    fs_info->file_handlers      = file_handlers;                      
   1d270:	e584a090 	str	sl, [r4, #144]	; 0x90                         <== NOT EXECUTED
    fs_info->directory_handlers = directory_handlers;                 
   1d274:	e584608c 	str	r6, [r4, #140]	; 0x8c                         <== NOT EXECUTED
     * open fat-file which correspondes to  root directory            
     * (so inode number 0x00000010 is always used for root directory) 
     */                                                               
    fat_dir_pos_init(&root_pos);                                      
    root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;                     
    rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);            
   1d278:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d27c:	e28d2014 	add	r2, sp, #20                                   <== NOT EXECUTED
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
   1d280:	e58d7008 	str	r7, [sp, #8]                                  <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
   1d284:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
   1d288:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
   1d28c:	eb001432 	bl	2235c <fat_file_open>                          <== NOT EXECUTED
    if (rc != RC_OK)                                                  
   1d290:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1d294:	0a000004 	beq	1d2ac <msdos_initialize_support+0x94>         <== NOT EXECUTED
    {                                                                 
        fat_shutdown_drive(temp_mt_entry);                            
   1d298:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d29c:	eb00160a 	bl	22acc <fat_shutdown_drive>                     <== NOT EXECUTED
        free(fs_info);                                                
   1d2a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1d2a4:	ebffa902 	bl	76b4 <free>                                    <== NOT EXECUTED
        return rc;                                                    
   1d2a8:	ea000043 	b	1d3bc <msdos_initialize_support+0x1a4>          <== NOT EXECUTED
    }                                                                 
                                                                      
    /* again: unfortunately "fat-file" is just almost fat file :( */  
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   1d2ac:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
   1d2b0:	e3a03602 	mov	r3, #2097152	; 0x200000                       <== NOT EXECUTED
   1d2b4:	e5813014 	str	r3, [r1, #20]                                 <== NOT EXECUTED
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
   1d2b8:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
                                                                      
    /* if we have FAT12/16 */                                         
    if ( fat_fd->cln == 0 )                                           
   1d2bc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    /* again: unfortunately "fat-file" is just almost fat file :( */  
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
   1d2c0:	e5818010 	str	r8, [r1, #16]                                 <== NOT EXECUTED
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
                                                                      
    fat_fd->map.file_cln = 0;                                         
   1d2c4:	e5817034 	str	r7, [r1, #52]	; 0x34                          <== NOT EXECUTED
    }                                                                 
                                                                      
    /* again: unfortunately "fat-file" is just almost fat file :( */  
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
   1d2c8:	e581301c 	str	r3, [r1, #28]                                 <== NOT EXECUTED
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
   1d2cc:	e5813038 	str	r3, [r1, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    /* if we have FAT12/16 */                                         
    if ( fat_fd->cln == 0 )                                           
   1d2d0:	1a000006 	bne	1d2f0 <msdos_initialize_support+0xd8>         <== NOT EXECUTED
    {                                                                 
        fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;           
   1d2d4:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
   1d2d8:	e5813018 	str	r3, [r1, #24]                                 <== NOT EXECUTED
        cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
   1d2dc:	e1d400b6 	ldrh	r0, [r4, #6]                                 <== NOT EXECUTED
   1d2e0:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
   1d2e4:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
   1d2e8:	31a00003 	movcc	r0, r3                                      <== NOT EXECUTED
   1d2ec:	ea000008 	b	1d314 <msdos_initialize_support+0xfc>           <== NOT EXECUTED
                      fs_info->fat.vol.bpc                                :
                      fs_info->fat.vol.rdir_size;                     
    }                                                                 
    else                                                              
    {                                                                 
        rc = fat_file_size(temp_mt_entry, fat_fd);                    
   1d2f0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d2f4:	eb001167 	bl	21898 <fat_file_size>                          <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   1d2f8:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
            fat_file_close(temp_mt_entry, fat_fd);                    
            fat_shutdown_drive(temp_mt_entry);                        
            free(fs_info);                                            
            return rc;                                                
        }                                                             
        cl_buf_size = fs_info->fat.vol.bpc;                           
   1d2fc:	01d400b6 	ldrheq	r0, [r4, #6]                               <== NOT EXECUTED
                      fs_info->fat.vol.rdir_size;                     
    }                                                                 
    else                                                              
    {                                                                 
        rc = fat_file_size(temp_mt_entry, fat_fd);                    
        if ( rc != RC_OK )                                            
   1d300:	0a000003 	beq	1d314 <msdos_initialize_support+0xfc>         <== NOT EXECUTED
        {                                                             
            fat_file_close(temp_mt_entry, fat_fd);                    
   1d304:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
   1d308:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d30c:	eb0013e9 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   1d310:	eaffffe0 	b	1d298 <msdos_initialize_support+0x80>           <== NOT EXECUTED
            return rc;                                                
        }                                                             
        cl_buf_size = fs_info->fat.vol.bpc;                           
    }                                                                 
                                                                      
    fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));   
   1d314:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1d318:	ebffa775 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if (fs_info->cl_buf == NULL)                                      
   1d31c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            return rc;                                                
        }                                                             
        cl_buf_size = fs_info->fat.vol.bpc;                           
    }                                                                 
                                                                      
    fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));   
   1d320:	e5840098 	str	r0, [r4, #152]	; 0x98                         <== NOT EXECUTED
    if (fs_info->cl_buf == NULL)                                      
   1d324:	1a00000b 	bne	1d358 <msdos_initialize_support+0x140>        <== NOT EXECUTED
    {                                                                 
        fat_file_close(temp_mt_entry, fat_fd);                        
   1d328:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
   1d32c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d330:	eb0013e0 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
        fat_shutdown_drive(temp_mt_entry);                            
   1d334:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d338:	eb0015e3 	bl	22acc <fat_shutdown_drive>                     <== NOT EXECUTED
        free(fs_info);                                                
   1d33c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1d340:	ebffa8db 	bl	76b4 <free>                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
   1d344:	eb007eed 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d348:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   1d34c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1d350:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   1d354:	ea000018 	b	1d3bc <msdos_initialize_support+0x1a4>          <== NOT EXECUTED
    }                                                                 
                                                                      
    sc = rtems_semaphore_create(3,                                    
   1d358:	e284c094 	add	ip, r4, #148	; 0x94                           <== NOT EXECUTED
   1d35c:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
   1d360:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1d364:	e3a02010 	mov	r2, #16                                       <== NOT EXECUTED
   1d368:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   1d36c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1d370:	ebffb8a9 	bl	b61c <rtems_semaphore_create>                  <== NOT EXECUTED
                                1,                                    
                                RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,  
                                0,                                    
                                &fs_info->vol_sema);                  
    if (sc != RTEMS_SUCCESSFUL)                                       
   1d374:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1d378:	0a00000b 	beq	1d3ac <msdos_initialize_support+0x194>        <== NOT EXECUTED
    {                                                                 
        fat_file_close(temp_mt_entry, fat_fd);                        
   1d37c:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
   1d380:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d384:	eb0013cb 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
        fat_shutdown_drive(temp_mt_entry);                            
   1d388:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d38c:	eb0015ce 	bl	22acc <fat_shutdown_drive>                     <== NOT EXECUTED
        free(fs_info->cl_buf);                                        
   1d390:	e5940098 	ldr	r0, [r4, #152]	; 0x98                         <== NOT EXECUTED
   1d394:	ebffa8c6 	bl	76b4 <free>                                    <== NOT EXECUTED
        free(fs_info);                                                
   1d398:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1d39c:	ebffa8c4 	bl	76b4 <free>                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
   1d3a0:	eb007ed6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d3a4:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   1d3a8:	eaffffe7 	b	1d34c <msdos_initialize_support+0x134>          <== NOT EXECUTED
    }                                                                 
                                                                      
    temp_mt_entry->mt_fs_root.node_access = fat_fd;                   
   1d3ac:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
    temp_mt_entry->mt_fs_root.handlers = directory_handlers;          
    temp_mt_entry->mt_fs_root.ops = op_table;                         
   1d3b0:	e5859028 	str	r9, [r5, #40]	; 0x28                          <== NOT EXECUTED
        free(fs_info->cl_buf);                                        
        free(fs_info);                                                
        rtems_set_errno_and_return_minus_one( EIO );                  
    }                                                                 
                                                                      
    temp_mt_entry->mt_fs_root.node_access = fat_fd;                   
   1d3b4:	e585301c 	str	r3, [r5, #28]                                 <== NOT EXECUTED
    temp_mt_entry->mt_fs_root.handlers = directory_handlers;          
   1d3b8:	e5856024 	str	r6, [r5, #36]	; 0x24                          <== NOT EXECUTED
    temp_mt_entry->mt_fs_root.ops = op_table;                         
                                                                      
    return rc;                                                        
}                                                                     
   1d3bc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1d3c0:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
   1d3c4:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

00032c54 <msdos_is_valid_name_char>: * MSDOS_NAME_LONG - Valid in a long name only. * */ static msdos_name_type_t msdos_is_valid_name_char(const char ch) {
   32c54:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   32c58:	e20040ff 	and	r4, r0, #255	; 0xff                           <== NOT EXECUTED
    if (strchr(" +,;=[]", ch) != NULL)                                
   32c5c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   32c60:	e59f004c 	ldr	r0, [pc, #76]	; 32cb4 <msdos_is_valid_name_char+0x60><== NOT EXECUTED
   32c64:	eb0040d3 	bl	42fb8 <strchr>                                 <== NOT EXECUTED
   32c68:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32c6c:	13a00002 	movne	r0, #2                                      <== NOT EXECUTED
   32c70:	18bd8010 	popne	{r4, pc}                                    <== NOT EXECUTED
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
   32c74:	e354002e 	cmp	r4, #46	; 0x2e                                <== NOT EXECUTED
   32c78:	0a00000b 	beq	32cac <msdos_is_valid_name_char+0x58>         <== NOT EXECUTED
   32c7c:	e59f3034 	ldr	r3, [pc, #52]	; 32cb8 <msdos_is_valid_name_char+0x64><== NOT EXECUTED
   32c80:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   32c84:	e0833004 	add	r3, r3, r4                                    <== NOT EXECUTED
   32c88:	e5d33001 	ldrb	r3, [r3, #1]                                 <== NOT EXECUTED
   32c8c:	e3130007 	tst	r3, #7                                        <== NOT EXECUTED
   32c90:	1a000005 	bne	32cac <msdos_is_valid_name_char+0x58>         <== NOT EXECUTED
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
   32c94:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   32c98:	e59f001c 	ldr	r0, [pc, #28]	; 32cbc <msdos_is_valid_name_char+0x68><== NOT EXECUTED
   32c9c:	eb0040c5 	bl	42fb8 <strchr>                                 <== NOT EXECUTED
   32ca0:	e2500000 	subs	r0, r0, #0                                   <== NOT EXECUTED
   32ca4:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
   32ca8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
   32cac:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
        return MSDOS_NAME_SHORT;                                      
                                                                      
    return MSDOS_NAME_INVALID;                                        
}                                                                     
   32cb0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00032da0 <msdos_long_to_short>: * */ #define MSDOS_L2S_PRINT 0 msdos_name_type_t msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len) {
   32da0:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
   32da4:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   32da8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int               i;                                              
                                                                      
    /*                                                                
     * Fill with spaces. This is how a short directory entry is padded.
     */                                                               
    memset (sfn, ' ', sfn_len);                                       
   32dac:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
 *                                                                    
 */                                                                   
#define MSDOS_L2S_PRINT 0                                             
msdos_name_type_t                                                     
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{                                                                     
   32db0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    int               i;                                              
                                                                      
    /*                                                                
     * Fill with spaces. This is how a short directory entry is padded.
     */                                                               
    memset (sfn, ' ', sfn_len);                                       
   32db4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   32db8:	e3a01020 	mov	r1, #32                                       <== NOT EXECUTED
   32dbc:	eb003586 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
   32dc0:	e5d43000 	ldrb	r3, [r4]                                     <== NOT EXECUTED
   32dc4:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   32dc8:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
   32dcc:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
   32dd0:	e3550001 	cmp	r5, #1                                        <== NOT EXECUTED
   32dd4:	0353002e 	cmpeq	r3, #46	; 0x2e                              <== NOT EXECUTED
    {                                                                 
        sfn[0] = '.';                                                 
   32dd8:	03a0302e 	moveq	r3, #46	; 0x2e                              <== NOT EXECUTED
   32ddc:	05c63000 	strbeq	r3, [r6]                                   <== NOT EXECUTED
    memset (sfn, ' ', sfn_len);                                       
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
   32de0:	0a000008 	beq	32e08 <msdos_long_to_short+0x68>              <== NOT EXECUTED
        printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_SHORT;                                      
    }                                                                 
                                                                      
    if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))         
   32de4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   32de8:	0a00000e 	beq	32e28 <msdos_long_to_short+0x88>              <== NOT EXECUTED
   32dec:	e5d43001 	ldrb	r3, [r4, #1]                                 <== NOT EXECUTED
   32df0:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   32df4:	03550002 	cmpeq	r5, #2                                      <== NOT EXECUTED
   32df8:	1a00000a 	bne	32e28 <msdos_long_to_short+0x88>              <== NOT EXECUTED
    {                                                                 
        sfn[0] = sfn[1] = '.';                                        
   32dfc:	e3a0302e 	mov	r3, #46	; 0x2e                                <== NOT EXECUTED
   32e00:	e5c63000 	strb	r3, [r6]                                     <== NOT EXECUTED
   32e04:	e5c63001 	strb	r3, [r6, #1]                                 <== NOT EXECUTED
   32e08:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
#if MSDOS_L2S_PRINT                                                   
        printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_SHORT;                                      
   32e0c:	ea000044 	b	32f24 <msdos_long_to_short+0x184>               <== NOT EXECUTED
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
   32e10:	e7d42003 	ldrb	r2, [r4, r3]                                 <== NOT EXECUTED
   32e14:	e352002e 	cmp	r2, #46	; 0x2e                                <== NOT EXECUTED
   32e18:	13520020 	cmpne	r2, #32                                     <== NOT EXECUTED
   32e1c:	1a00002c 	bne	32ed4 <msdos_long_to_short+0x134>             <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
   32e20:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   32e24:	ea000000 	b	32e2c <msdos_long_to_short+0x8c>                <== NOT EXECUTED
   32e28:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   32e2c:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
   32e30:	bafffff6 	blt	32e10 <msdos_long_to_short+0x70>              <== NOT EXECUTED
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
            break;                                                    
                                                                      
    if (i == lfn_len)                                                 
   32e34:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   32e38:	1a000025 	bne	32ed4 <msdos_long_to_short+0x134>             <== NOT EXECUTED
   32e3c:	ea000038 	b	32f24 <msdos_long_to_short+0x184>               <== NOT EXECUTED
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
        msdos_name_type_t type = msdos_is_valid_name_char(*name);     
   32e40:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   32e44:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
   32e48:	ebffff81 	bl	32c54 <msdos_is_valid_name_char>               <== NOT EXECUTED
                                                                      
#if MSDOS_NAME_TYPE_PRINT                                             
        printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);    
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
   32e4c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32e50:	13500002 	cmpne	r0, #2                                      <== NOT EXECUTED
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
        msdos_name_type_t type = msdos_is_valid_name_char(*name);     
   32e54:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
#if MSDOS_NAME_TYPE_PRINT                                             
        printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);    
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
   32e58:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   32e5c:	0a000029 	beq	32f08 <msdos_long_to_short+0x168>             <== NOT EXECUTED
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
   32e60:	e35a002e 	cmp	sl, #46	; 0x2e                                <== NOT EXECUTED
   32e64:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
   32e68:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
            return type;                                              
                                                                      
        if (dot_at >= 0)                                              
   32e6c:	e37b0001 	cmn	fp, #1                                        <== NOT EXECUTED
   32e70:	0a000005 	beq	32e8c <msdos_long_to_short+0xec>              <== NOT EXECUTED
        {                                                             
            if (is_dot || ((count - dot_at) > 3))                     
   32e74:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   32e78:	1a00002c 	bne	32f30 <msdos_long_to_short+0x190>             <== NOT EXECUTED
   32e7c:	e06b2008 	rsb	r2, fp, r8                                    <== NOT EXECUTED
   32e80:	e3520003 	cmp	r2, #3                                        <== NOT EXECUTED
   32e84:	da000007 	ble	32ea8 <msdos_long_to_short+0x108>             <== NOT EXECUTED
   32e88:	ea000028 	b	32f30 <msdos_long_to_short+0x190>               <== NOT EXECUTED
                return MSDOS_NAME_LONG;                               
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            if (count == 8 && !is_dot)                                
   32e8c:	e3580008 	cmp	r8, #8                                        <== NOT EXECUTED
   32e90:	1a000002 	bne	32ea0 <msdos_long_to_short+0x100>             <== NOT EXECUTED
   32e94:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   32e98:	1a00000a 	bne	32ec8 <msdos_long_to_short+0x128>             <== NOT EXECUTED
   32e9c:	ea000023 	b	32f30 <msdos_long_to_short+0x190>               <== NOT EXECUTED
#endif                                                                
                return MSDOS_NAME_LONG;                               
            }                                                         
        }                                                             
                                                                      
        if (is_dot)                                                   
   32ea0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   32ea4:	1a000007 	bne	32ec8 <msdos_long_to_short+0x128>             <== NOT EXECUTED
            dot_at = count;                                           
        else if ((*name >= 'A') && (*name <= 'Z'))                    
   32ea8:	e24a2041 	sub	r2, sl, #65	; 0x41                            <== NOT EXECUTED
   32eac:	e3520019 	cmp	r2, #25                                       <== NOT EXECUTED
   32eb0:	93a03001 	movls	r3, #1                                      <== NOT EXECUTED
   32eb4:	9a000004 	bls	32ecc <msdos_long_to_short+0x12c>             <== NOT EXECUTED
            uppercase = true;                                         
        else if ((*name >= 'a') && (*name <= 'z'))                    
   32eb8:	e24aa061 	sub	sl, sl, #97	; 0x61                            <== NOT EXECUTED
   32ebc:	e35a0019 	cmp	sl, #25                                       <== NOT EXECUTED
   32ec0:	93a09001 	movls	r9, #1                                      <== NOT EXECUTED
   32ec4:	ea000000 	b	32ecc <msdos_long_to_short+0x12c>               <== NOT EXECUTED
   32ec8:	e1a0b008 	mov	fp, r8                                        <== NOT EXECUTED
            lowercase = true;                                         
                                                                      
        count++;                                                      
   32ecc:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   32ed0:	ea000003 	b	32ee4 <msdos_long_to_short+0x144>               <== NOT EXECUTED
   32ed4:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
   32ed8:	e3e0b000 	mvn	fp, #0                                        <== NOT EXECUTED
   32edc:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   32ee0:	e1a09008 	mov	r9, r8                                        <== NOT EXECUTED
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
   32ee4:	e7d4a008 	ldrb	sl, [r4, r8]                                 <== NOT EXECUTED
   32ee8:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   32eec:	11580005 	cmpne	r8, r5                                      <== NOT EXECUTED
   32ef0:	baffffd2 	blt	32e40 <msdos_long_to_short+0xa0>              <== NOT EXECUTED
                                                                      
        count++;                                                      
        name++;                                                       
    }                                                                 
                                                                      
    if (lowercase && uppercase)                                       
   32ef4:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   32ef8:	0a00000a 	beq	32f28 <msdos_long_to_short+0x188>             <== NOT EXECUTED
   32efc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   32f00:	1a00000a 	bne	32f30 <msdos_long_to_short+0x190>             <== NOT EXECUTED
   32f04:	ea000007 	b	32f28 <msdos_long_to_short+0x188>               <== NOT EXECUTED
     * Is this a short name ?                                         
     */                                                               
                                                                      
    type = msdos_name_type (lfn, lfn_len);                            
                                                                      
    if (type == MSDOS_NAME_INVALID)                                   
   32f08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32f0c:	0a000004 	beq	32f24 <msdos_long_to_short+0x184>             <== NOT EXECUTED
        printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_INVALID;                                    
    }                                                                 
                                                                      
    msdos_filename_unix2dos (lfn, lfn_len, sfn);                      
   32f10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   32f14:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   32f18:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   32f1c:	eb002285 	bl	3b938 <msdos_filename_unix2dos>                <== NOT EXECUTED
   32f20:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
}                                                                     
   32f24:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
    msdos_filename_unix2dos (lfn, lfn_len, sfn);                      
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
   32f28:	e3a07001 	mov	r7, #1                                        <== NOT EXECUTED
   32f2c:	eafffff7 	b	32f10 <msdos_long_to_short+0x170>               <== NOT EXECUTED
   32f30:	e3a07002 	mov	r7, #2                                        <== NOT EXECUTED
   32f34:	eafffff5 	b	32f10 <msdos_long_to_short+0x170>               <== NOT EXECUTED
                                                                      

0001d3c8 <msdos_mknod>: const char *name, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) {
   1d3c8:	e92d45f3 	push	{r0, r1, r4, r5, r6, r7, r8, sl, lr}         <== NOT EXECUTED
   1d3cc:	e59d8024 	ldr	r8, [sp, #36]	; 0x24                          <== NOT EXECUTED
    msdos_token_types_t  type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
   1d3d0:	e2013a0f 	and	r3, r1, #61440	; 0xf000                       <== NOT EXECUTED
    rtems_filesystem_location_info_t  *pathloc                        
)                                                                     
{                                                                     
    int                  rc = RC_OK;                                  
    rtems_status_code    sc = RTEMS_SUCCESSFUL;                       
    msdos_fs_info_t     *fs_info = pathloc->mt_entry->fs_info;        
   1d3d4:	e5982010 	ldr	r2, [r8, #16]                                 <== NOT EXECUTED
    msdos_token_types_t  type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
   1d3d8:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
    const char                        *name,                          
    mode_t                             mode,                          
    dev_t                              dev,                           
    rtems_filesystem_location_info_t  *pathloc                        
)                                                                     
{                                                                     
   1d3dc:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   1d3e0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    int                  rc = RC_OK;                                  
    rtems_status_code    sc = RTEMS_SUCCESSFUL;                       
    msdos_fs_info_t     *fs_info = pathloc->mt_entry->fs_info;        
   1d3e4:	e5924034 	ldr	r4, [r2, #52]	; 0x34                          <== NOT EXECUTED
    msdos_token_types_t  type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
   1d3e8:	0a000005 	beq	1d404 <msdos_mknod+0x3c>                      <== NOT EXECUTED
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
    }                                                                 
    else if (S_ISREG(mode))                                           
   1d3ec:	e3530902 	cmp	r3, #32768	; 0x8000                           <== NOT EXECUTED
   1d3f0:	03a0a005 	moveq	sl, #5                                      <== NOT EXECUTED
   1d3f4:	0a000003 	beq	1d408 <msdos_mknod+0x40>                      <== NOT EXECUTED
    {                                                                 
        type = MSDOS_REGULAR_FILE;                                    
    }                                                                 
    else                                                              
        rtems_set_errno_and_return_minus_one(EINVAL);                 
   1d3f8:	eb007ec0 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d3fc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1d400:	ea000008 	b	1d428 <msdos_mknod+0x60>                        <== NOT EXECUTED
   1d404:	e3a0a001 	mov	sl, #1                                        <== NOT EXECUTED
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   1d408:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1d40c:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   1d410:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1d414:	ebffb929 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   1d418:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1d41c:	0a000004 	beq	1d434 <msdos_mknod+0x6c>                      <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
   1d420:	eb007eb6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d424:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   1d428:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1d42c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   1d430:	ea00000a 	b	1d460 <msdos_mknod+0x98>                        <== NOT EXECUTED
                                                                      
    /* Create an MSDOS node */                                        
    rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
   1d434:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1d438:	eb0099ad 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1d43c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1d440:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1d444:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1d448:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   1d44c:	e88d0060 	stm	sp, {r5, r6}                                  <== NOT EXECUTED
   1d450:	eb004eab 	bl	30f04 <msdos_creat_node>                       <== NOT EXECUTED
   1d454:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   1d458:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   1d45c:	ebffb95d 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   1d460:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d464:	e8bd85fc 	pop	{r2, r3, r4, r5, r6, r7, r8, sl, pc}          <== NOT EXECUTED
                                                                      

0001d468 <msdos_node_type>: * node type * */ rtems_filesystem_node_types_t msdos_node_type(rtems_filesystem_location_info_t *pathloc) {
   1d468:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
     * call                                                           
     */                                                               
    fat_fd = pathloc->node_access;                                    
                                                                      
    return fat_fd->fat_file_type;                                     
}                                                                     
   1d46c:	e5930010 	ldr	r0, [r3, #16]                                 <== NOT EXECUTED
   1d470:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001d474 <msdos_rename>: int msdos_rename(rtems_filesystem_location_info_t *old_parent_loc, rtems_filesystem_location_info_t *old_loc, rtems_filesystem_location_info_t *new_parent_loc, const char *new_name) {
   1d474:	e92d45ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
   1d478:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info     = new_parent_loc->mt_entry->fs_info;
   1d47c:	e5923010 	ldr	r3, [r2, #16]                                 <== NOT EXECUTED
    int                len;                                           
                                                                      
    /*                                                                
     * check spelling and format new node name                        
     */                                                               
    if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
   1d480:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
int                                                                   
msdos_rename(rtems_filesystem_location_info_t  *old_parent_loc,       
             rtems_filesystem_location_info_t  *old_loc,              
             rtems_filesystem_location_info_t  *new_parent_loc,       
             const char                        *new_name)             
{                                                                     
   1d484:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info     = new_parent_loc->mt_entry->fs_info;
   1d488:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
msdos_rename(rtems_filesystem_location_info_t  *old_parent_loc,       
             rtems_filesystem_location_info_t  *old_loc,              
             rtems_filesystem_location_info_t  *new_parent_loc,       
             const char                        *new_name)             
{                                                                     
   1d48c:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
    int                len;                                           
                                                                      
    /*                                                                
     * check spelling and format new node name                        
     */                                                               
    if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
   1d490:	eb009997 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1d494:	e28d200c 	add	r2, sp, #12                                   <== NOT EXECUTED
   1d498:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   1d49c:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
   1d4a0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
             const char                        *new_name)             
{                                                                     
    int                rc = RC_OK;                                    
    rtems_status_code  sc = RTEMS_SUCCESSFUL;                         
    msdos_fs_info_t   *fs_info     = new_parent_loc->mt_entry->fs_info;
    fat_file_fd_t     *old_fat_fd  = old_loc->node_access;            
   1d4a4:	e5968000 	ldr	r8, [r6]                                      <== NOT EXECUTED
    int                len;                                           
                                                                      
    /*                                                                
     * check spelling and format new node name                        
     */                                                               
    if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
   1d4a8:	eb005604 	bl	32cc0 <msdos_get_token>                        <== NOT EXECUTED
   1d4ac:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
   1d4b0:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
   1d4b4:	0a000002 	beq	1d4c4 <msdos_rename+0x50>                     <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one(ENAMETOOLONG);             
   1d4b8:	eb007e90 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d4bc:	e3a0305b 	mov	r3, #91	; 0x5b                                <== NOT EXECUTED
   1d4c0:	ea000007 	b	1d4e4 <msdos_rename+0x70>                       <== NOT EXECUTED
    }                                                                 
    /*                                                                
     * lock volume                                                    
     */                                                               
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
   1d4c4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1d4c8:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   1d4cc:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1d4d0:	ebffb8fa 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   1d4d4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1d4d8:	0a000004 	beq	1d4f0 <msdos_rename+0x7c>                     <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one(EIO);                      
   1d4dc:	eb007e87 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d4e0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   1d4e4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1d4e8:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   1d4ec:	ea000010 	b	1d534 <msdos_rename+0xc0>                       <== NOT EXECUTED
                                                                      
    /*                                                                
     * create new directory entry as "hard link", copying relevant info from
     * existing file                                                  
     */                                                               
    rc = msdos_creat_node(new_parent_loc,                             
   1d4f0:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   1d4f4:	e3a0c902 	mov	ip, #32768	; 0x8000                           <== NOT EXECUTED
   1d4f8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1d4fc:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1d500:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   1d504:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1d508:	e58d8004 	str	r8, [sp, #4]                                  <== NOT EXECUTED
   1d50c:	eb004e7c 	bl	30f04 <msdos_creat_node>                       <== NOT EXECUTED
                          MSDOS_HARD_LINK,new_name,len,S_IFREG,       
                          old_fat_fd);                                
    if (rc != RC_OK)                                                  
   1d510:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1d514:	1a000004 	bne	1d52c <msdos_rename+0xb8>                     <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * mark file removed                                              
     */                                                               
    rc = msdos_set_first_char4file_name(old_loc->mt_entry,            
   1d518:	e5960010 	ldr	r0, [r6, #16]                                 <== NOT EXECUTED
   1d51c:	e2881020 	add	r1, r8, #32                                   <== NOT EXECUTED
   1d520:	e3a020e5 	mov	r2, #229	; 0xe5                               <== NOT EXECUTED
   1d524:	eb00554e 	bl	32a64 <msdos_set_first_char4file_name>         <== NOT EXECUTED
   1d528:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                        &old_fat_fd->dir_pos,         
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
   1d52c:	e5940094 	ldr	r0, [r4, #148]	; 0x94                         <== NOT EXECUTED
   1d530:	ebffb928 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
   1d534:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d538:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   1d53c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

00032ba0 <msdos_set_dir_wrt_time_and_date>: int msdos_set_dir_wrt_time_and_date( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd ) {
   32ba0:	e92d40f3 	push	{r0, r1, r4, r5, r6, r7, lr}                 <== NOT EXECUTED
   32ba4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   32ba8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    uint16_t         time_val;                                        
    uint16_t         date;                                            
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);             
   32bac:	e28d2006 	add	r2, sp, #6                                    <== NOT EXECUTED
   32bb0:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
   32bb4:	e5950040 	ldr	r0, [r5, #64]	; 0x40                          <== NOT EXECUTED
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   32bb8:	e5947034 	ldr	r7, [r4, #52]	; 0x34                          <== NOT EXECUTED
    uint16_t         time_val;                                        
    uint16_t         date;                                            
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);             
   32bbc:	eb0022c9 	bl	3b6e8 <msdos_date_unix2dos>                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * calculate input for _fat_block_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
   32bc0:	e5952020 	ldr	r2, [r5, #32]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32bc4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   32bc8:	e5943034 	ldr	r3, [r4, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32bcc:	1a000003 	bne	32be0 <msdos_set_dir_wrt_time_and_date+0x40>  <== NOT EXECUTED
   32bd0:	e5d3100a 	ldrb	r1, [r3, #10]                                <== NOT EXECUTED
   32bd4:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   32bd8:	1593601c 	ldrne	r6, [r3, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32bdc:	1a000003 	bne	32bf0 <msdos_set_dir_wrt_time_and_date+0x50>  <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   32be0:	e5931030 	ldr	r1, [r3, #48]	; 0x30                          <== NOT EXECUTED
   32be4:	e5d33005 	ldrb	r3, [r3, #5]                                 <== NOT EXECUTED
   32be8:	e2426002 	sub	r6, r2, #2                                    <== NOT EXECUTED
   32bec:	e0816316 	add	r6, r1, r6, lsl r3                            <== NOT EXECUTED
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
   32bf0:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
   32bf4:	e5d72002 	ldrb	r2, [r7, #2]                                 <== NOT EXECUTED
   32bf8:	e0866233 	add	r6, r6, r3, lsr r2                            <== NOT EXECUTED
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
   32bfc:	e1d750b0 	ldrh	r5, [r7]                                     <== NOT EXECUTED
   32c00:	e2455001 	sub	r5, r5, #1                                    <== NOT EXECUTED
   32c04:	e0055003 	and	r5, r5, r3                                    <== NOT EXECUTED
                                                                      
    time_val = CT_LE_W(time_val);                                     
    ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
   32c08:	e28dc006 	add	ip, sp, #6                                    <== NOT EXECUTED
   32c0c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   32c10:	e2852016 	add	r2, r5, #22                                   <== NOT EXECUTED
   32c14:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   32c18:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   32c1c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32c20:	ebffbf65 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
    ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
   32c24:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    time_val = CT_LE_W(time_val);                                     
    ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
   32c28:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
    ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
   32c2c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   32c30:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   32c34:	e2852018 	add	r2, r5, #24                                   <== NOT EXECUTED
   32c38:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   32c3c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32c40:	ebffbf5d 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                            2, (char *)(&date));                      
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) )                                   
   32c44:	e1a07fa7 	lsr	r7, r7, #31                                   <== NOT EXECUTED
   32c48:	e1970fa0 	orrs	r0, r7, r0, lsr #31                          <== NOT EXECUTED
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
   32c4c:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
   32c50:	e8bd80fc 	pop	{r2, r3, r4, r5, r6, r7, pc}                  <== NOT EXECUTED
                                                                      

00032938 <msdos_set_file_size>: msdos_fs_info_t *fs_info = mt_entry->fs_info; uint32_t le_new_length = 0; uint32_t sec = 0; uint32_t byte = 0; sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
   32938:	e5913020 	ldr	r3, [r1, #32]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   3293c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
int                                                                   
msdos_set_file_size(                                                  
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   32940:	e92d4013 	push	{r0, r1, r4, lr}                             <== NOT EXECUTED
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   32944:	e590c034 	ldr	ip, [r0, #52]	; 0x34                          <== NOT EXECUTED
   32948:	1a000003 	bne	3295c <msdos_set_file_size+0x24>              <== NOT EXECUTED
   3294c:	e5dc200a 	ldrb	r2, [ip, #10]                                <== NOT EXECUTED
   32950:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   32954:	159c301c 	ldrne	r3, [ip, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32958:	1a000003 	bne	3296c <msdos_set_file_size+0x34>              <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   3295c:	e5dce005 	ldrb	lr, [ip, #5]                                 <== NOT EXECUTED
   32960:	e59c2030 	ldr	r2, [ip, #48]	; 0x30                          <== NOT EXECUTED
   32964:	e2433002 	sub	r3, r3, #2                                    <== NOT EXECUTED
   32968:	e0823e13 	add	r3, r2, r3, lsl lr                            <== NOT EXECUTED
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
   3296c:	e1dc20b0 	ldrh	r2, [ip]                                     <== NOT EXECUTED
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
   32970:	e5914018 	ldr	r4, [r1, #24]                                 <== NOT EXECUTED
    uint32_t         le_new_length = 0;                               
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
   32974:	e5911024 	ldr	r1, [r1, #36]	; 0x24                          <== NOT EXECUTED
   32978:	e5dce002 	ldrb	lr, [ip, #2]                                 <== NOT EXECUTED
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
   3297c:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
   32980:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
   32984:	e52c4004 	str	r4, [ip, #-4]!                                <== NOT EXECUTED
    uint32_t         sec = 0;                                         
    uint32_t         byte = 0;                                        
                                                                      
    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
   32988:	e0022001 	and	r2, r2, r1                                    <== NOT EXECUTED
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
    ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
   3298c:	e282201c 	add	r2, r2, #28                                   <== NOT EXECUTED
   32990:	e0831e31 	add	r1, r3, r1, lsr lr                            <== NOT EXECUTED
   32994:	e3a03004 	mov	r3, #4                                        <== NOT EXECUTED
   32998:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   3299c:	ebffc006 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                           (char *)(&le_new_length));                 
    if ( ret < 0 )                                                    
   329a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
   329a4:	b3e00000 	mvnlt	r0, #0                                      <== NOT EXECUTED
   329a8:	a3a00000 	movge	r0, #0                                      <== NOT EXECUTED
   329ac:	e8bd801c 	pop	{r2, r3, r4, pc}                              <== NOT EXECUTED
                                                                      

00032a64 <msdos_set_first_char4file_name>: msdos_set_first_char4file_name( rtems_filesystem_mount_table_entry_t *mt_entry, fat_dir_pos_t *dir_pos, unsigned char fchar ) {
   32a64:	e92d47ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}<== NOT EXECUTED
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
   32a68:	e2814008 	add	r4, r1, #8                                    <== NOT EXECUTED
   32a6c:	e8940018 	ldm	r4, {r3, r4}                                  <== NOT EXECUTED
msdos_set_first_char4file_name(                                       
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_dir_pos_t                        *dir_pos,                    
    unsigned char                         fchar                       
    )                                                                 
{                                                                     
   32a70:	e5cd2004 	strb	r2, [sp, #4]                                 <== NOT EXECUTED
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
   32a74:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   32a78:	e58d400c 	str	r4, [sp, #12]                                 <== NOT EXECUTED
    fat_dir_pos_t                        *dir_pos,                    
    unsigned char                         fchar                       
    )                                                                 
{                                                                     
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   32a7c:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
    fat_pos_t        end = dir_pos->sname;                            
   32a80:	e5916000 	ldr	r6, [r1]                                      <== NOT EXECUTED
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
   32a84:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
   32a88:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
msdos_set_first_char4file_name(                                       
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_dir_pos_t                        *dir_pos,                    
    unsigned char                         fchar                       
    )                                                                 
{                                                                     
   32a8c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
    fat_pos_t        end = dir_pos->sname;                            
   32a90:	e5918004 	ldr	r8, [r1, #4]                                  <== NOT EXECUTED
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
   32a94:	1a000003 	bne	32aa8 <msdos_set_first_char4file_name+0x44>   <== NOT EXECUTED
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
   32a98:	e5d4300a 	ldrb	r3, [r4, #10]                                <== NOT EXECUTED
   32a9c:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
      dir_block_size = fs_info->fat.vol.rdir_size;                    
   32aa0:	15947028 	ldrne	r7, [r4, #40]	; 0x28                        <== NOT EXECUTED
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
    fat_pos_t        end = dir_pos->sname;                            
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
   32aa4:	1a000000 	bne	32aac <msdos_set_first_char4file_name+0x48>   <== NOT EXECUTED
      dir_block_size = fs_info->fat.vol.rdir_size;                    
    else                                                              
      dir_block_size = fs_info->fat.vol.bpc;                          
   32aa8:	e1d470b6 	ldrh	r7, [r4, #6]                                 <== NOT EXECUTED
                                                                      
    if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)                    
   32aac:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
   32ab0:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
      start = dir_pos->sname;                                         
   32ab4:	0891000c 	ldmeq	r1, {r2, r3}                                <== NOT EXECUTED
   32ab8:	058d2008 	streq	r2, [sp, #8]                                <== NOT EXECUTED
   32abc:	058d300c 	streq	r3, [sp, #12]                               <== NOT EXECUTED
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;      
                                                                      
      ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
   32ac0:	e28da004 	add	sl, sp, #4                                    <== NOT EXECUTED
      {                                                               
        int rc;                                                       
        if ((end.cln == fs_info->fat.vol.rdir_cl) &&                  
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
          break;                                                      
        rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);    
   32ac4:	e28d9008 	add	r9, sp, #8                                    <== NOT EXECUTED
     * name code was written rather than use the fat_file_write       
     * interface.                                                     
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
   32ac8:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32acc:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
fat_cluster_num_to_sector_num(                                        
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
   32ad0:	e5953034 	ldr	r3, [r5, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32ad4:	1a000003 	bne	32ae8 <msdos_set_first_char4file_name+0x84>   <== NOT EXECUTED
   32ad8:	e5d3100a 	ldrb	r1, [r3, #10]                                <== NOT EXECUTED
   32adc:	e3110003 	tst	r1, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   32ae0:	1593101c 	ldrne	r1, [r3, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   32ae4:	1a000003 	bne	32af8 <msdos_set_first_char4file_name+0x94>   <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   32ae8:	e5930030 	ldr	r0, [r3, #48]	; 0x30                          <== NOT EXECUTED
   32aec:	e5d33005 	ldrb	r3, [r3, #5]                                 <== NOT EXECUTED
   32af0:	e2421002 	sub	r1, r2, #2                                    <== NOT EXECUTED
   32af4:	e0801311 	add	r1, r0, r1, lsl r3                            <== NOT EXECUTED
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;      
                                                                      
      ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
   32af8:	e1d420b0 	ldrh	r2, [r4]                                     <== NOT EXECUTED
     * interface.                                                     
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
   32afc:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;      
                                                                      
      ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
   32b00:	e5d40002 	ldrb	r0, [r4, #2]                                 <== NOT EXECUTED
   32b04:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   32b08:	e0811033 	add	r1, r1, r3, lsr r0                            <== NOT EXECUTED
   32b0c:	e0022003 	and	r2, r2, r3                                    <== NOT EXECUTED
   32b10:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   32b14:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   32b18:	e58da000 	str	sl, [sp]                                      <== NOT EXECUTED
   32b1c:	ebffbfa6 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                             &fchar);                                 
      if (ret < 0)                                                    
   32b20:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32b24:	ba000018 	blt	32b8c <msdos_set_first_char4file_name+0x128>  <== NOT EXECUTED
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
   32b28:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   32b2c:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
   32b30:	1a000002 	bne	32b40 <msdos_set_first_char4file_name+0xdc>   <== NOT EXECUTED
   32b34:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   32b38:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
   32b3c:	0a000014 	beq	32b94 <msdos_set_first_char4file_name+0x130>  <== NOT EXECUTED
        break;                                                        
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
   32b40:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   32b44:	e2833020 	add	r3, r3, #32                                   <== NOT EXECUTED
      if (start.ofs >= dir_block_size)                                
   32b48:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
        break;                                                        
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
   32b4c:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
      if (start.ofs >= dir_block_size)                                
   32b50:	3affffdc 	bcc	32ac8 <msdos_set_first_char4file_name+0x64>   <== NOT EXECUTED
      {                                                               
        int rc;                                                       
        if ((end.cln == fs_info->fat.vol.rdir_cl) &&                  
   32b54:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
   32b58:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
   32b5c:	1a000002 	bne	32b6c <msdos_set_first_char4file_name+0x108>  <== NOT EXECUTED
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
   32b60:	e5d4300a 	ldrb	r3, [r4, #10]                                <== NOT EXECUTED
   32b64:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
   32b68:	1a000009 	bne	32b94 <msdos_set_first_char4file_name+0x130>  <== NOT EXECUTED
          break;                                                      
        rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);    
   32b6c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   32b70:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
   32b74:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   32b78:	eb0019e6 	bl	39318 <fat_get_fat_cluster>                    <== NOT EXECUTED
        if ( rc != RC_OK )                                            
   32b7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   32b80:	1a000004 	bne	32b98 <msdos_set_first_char4file_name+0x134>  <== NOT EXECUTED
          return rc;                                                  
        start.ofs = 0;                                                
   32b84:	e58d000c 	str	r0, [sp, #12]                                 <== NOT EXECUTED
   32b88:	eaffffce 	b	32ac8 <msdos_set_first_char4file_name+0x64>     <== NOT EXECUTED
   32b8c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   32b90:	ea000000 	b	32b98 <msdos_set_first_char4file_name+0x134>    <== NOT EXECUTED
   32b94:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
}                                                                     
   32b98:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   32b9c:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

000329b0 <msdos_set_first_cluster_num>: /* * calculate input for _fat_block_write: convert (cluster num, offset) to * (sector num, new offset) */ sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
   329b0:	e5913020 	ldr	r3, [r1, #32]                                 <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   329b4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
int                                                                   
msdos_set_first_cluster_num(                                          
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   329b8:	e92d41f3 	push	{r0, r1, r4, r5, r6, r7, r8, lr}             <== NOT EXECUTED
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
   329bc:	e5902034 	ldr	r2, [r0, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
msdos_set_first_cluster_num(                                          
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
   329c0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         new_cln = fat_fd->cln;                           
   329c4:	e591701c 	ldr	r7, [r1, #28]                                 <== NOT EXECUTED
   329c8:	1a000003 	bne	329dc <msdos_set_first_cluster_num+0x2c>      <== NOT EXECUTED
   329cc:	e5d2000a 	ldrb	r0, [r2, #10]                                <== NOT EXECUTED
   329d0:	e3100003 	tst	r0, #3                                        <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
   329d4:	1592301c 	ldrne	r3, [r2, #28]                               <== NOT EXECUTED
    uint32_t                              cln                         
    )                                                                 
{                                                                     
    register fat_fs_info_t *fs_info = mt_entry->fs_info;              
                                                                      
    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
   329d8:	1a000003 	bne	329ec <msdos_set_first_cluster_num+0x3c>      <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
   329dc:	e5d2c005 	ldrb	ip, [r2, #5]                                 <== NOT EXECUTED
   329e0:	e5920030 	ldr	r0, [r2, #48]	; 0x30                          <== NOT EXECUTED
   329e4:	e2433002 	sub	r3, r3, #2                                    <== NOT EXECUTED
   329e8:	e0803c13 	add	r3, r0, r3, lsl ip                            <== NOT EXECUTED
    /*                                                                
     * calculate input for _fat_block_write: convert (cluster num, offset) to
     * (sector num, new offset)                                       
     */                                                               
    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
   329ec:	e5d26002 	ldrb	r6, [r2, #2]                                 <== NOT EXECUTED
   329f0:	e5911024 	ldr	r1, [r1, #36]	; 0x24                          <== NOT EXECUTED
   329f4:	e0836631 	add	r6, r3, r1, lsr r6                            <== NOT EXECUTED
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
   329f8:	e1d250b0 	ldrh	r5, [r2]                                     <== NOT EXECUTED
   329fc:	e2455001 	sub	r5, r5, #1                                    <== NOT EXECUTED
   32a00:	e0055001 	and	r5, r5, r1                                    <== NOT EXECUTED
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = _fat_block_write(mt_entry, sec,                            
   32a04:	e28dc006 	add	ip, sp, #6                                    <== NOT EXECUTED
   32a08:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   32a0c:	e285201a 	add	r2, r5, #26                                   <== NOT EXECUTED
   32a10:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32a14:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
{                                                                     
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         new_cln = fat_fd->cln;                           
    uint16_t         le_cl_low = 0;                                   
    uint16_t         le_cl_hi = 0;                                    
   32a18:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = _fat_block_write(mt_entry, sec,                            
   32a1c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
   32a20:	e1cd70b6 	strh	r7, [sp, #6]                                 <== NOT EXECUTED
{                                                                     
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         new_cln = fat_fd->cln;                           
    uint16_t         le_cl_low = 0;                                   
    uint16_t         le_cl_hi = 0;                                    
   32a24:	e1cdc0b4 	strh	ip, [sp, #4]                                 <== NOT EXECUTED
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = _fat_block_write(mt_entry, sec,                            
   32a28:	ebffbfe3 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2, 
                            (char *)(&le_cl_low));                    
    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));   
   32a2c:	e1a07827 	lsr	r7, r7, #16                                   <== NOT EXECUTED
   32a30:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
   32a34:	e16c70b4 	strh	r7, [ip, #-4]!                               <== NOT EXECUTED
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
    ret1 = _fat_block_write(mt_entry, sec,                            
   32a38:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2, 
                            (char *)(&le_cl_low));                    
    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));   
    ret2 = _fat_block_write(mt_entry, sec,                            
   32a3c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   32a40:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   32a44:	e2852014 	add	r2, r5, #20                                   <== NOT EXECUTED
   32a48:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   32a4c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   32a50:	ebffbfd9 	bl	229bc <_fat_block_write>                       <== NOT EXECUTED
                            byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,  
                            (char *)(&le_cl_hi));                     
    if ( (ret1 < 0) || (ret2 < 0) )                                   
   32a54:	e1a08fa8 	lsr	r8, r8, #31                                   <== NOT EXECUTED
   32a58:	e1980fa0 	orrs	r0, r8, r0, lsr #31                          <== NOT EXECUTED
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
   32a5c:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
   32a60:	e8bd81fc 	pop	{r2, r3, r4, r5, r6, r7, r8, pc}              <== NOT EXECUTED
                                                                      

00031da4 <msdos_shut_down>: * RC_OK on success, or -1 if error occured (errno set apropriately). * */ int msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry) {
   31da4:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;                
    fat_file_fd_t   *fat_fd = temp_mt_entry->mt_fs_root.node_access;  
                                                                      
    /* close fat-file which correspondes to root directory */         
    if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)               
   31da8:	e590101c 	ldr	r1, [r0, #28]                                 <== NOT EXECUTED
 *     RC_OK on success, or -1 if error occured (errno set apropriately).
 *                                                                    
 */                                                                   
int                                                                   
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)  
{                                                                     
   31dac:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;                
   31db0:	e5905034 	ldr	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
    fat_file_fd_t   *fat_fd = temp_mt_entry->mt_fs_root.node_access;  
                                                                      
    /* close fat-file which correspondes to root directory */         
    if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)               
   31db4:	ebffc13f 	bl	222b8 <fat_file_close>                         <== NOT EXECUTED
   31db8:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    {                                                                 
        /* no return - try to free as much as possible */             
        rc = -1;                                                      
    }                                                                 
                                                                      
    if (fat_shutdown_drive(temp_mt_entry) != RC_OK)                   
   31dbc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;                
    fat_file_fd_t   *fat_fd = temp_mt_entry->mt_fs_root.node_access;  
                                                                      
    /* close fat-file which correspondes to root directory */         
    if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)               
   31dc0:	13e06000 	mvnne	r6, #0                                      <== NOT EXECUTED
    {                                                                 
        /* no return - try to free as much as possible */             
        rc = -1;                                                      
    }                                                                 
                                                                      
    if (fat_shutdown_drive(temp_mt_entry) != RC_OK)                   
   31dc4:	ebffc340 	bl	22acc <fat_shutdown_drive>                     <== NOT EXECUTED
   31dc8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    {                                                                 
        /* no return - try to free as much as possible */             
        rc = -1;                                                      
    }                                                                 
                                                                      
    rtems_semaphore_delete(fs_info->vol_sema);                        
   31dcc:	e5950094 	ldr	r0, [r5, #148]	; 0x94                         <== NOT EXECUTED
    {                                                                 
        /* no return - try to free as much as possible */             
        rc = -1;                                                      
    }                                                                 
                                                                      
    if (fat_shutdown_drive(temp_mt_entry) != RC_OK)                   
   31dd0:	13e06000 	mvnne	r6, #0                                      <== NOT EXECUTED
    {                                                                 
        /* no return - try to free as much as possible */             
        rc = -1;                                                      
    }                                                                 
                                                                      
    rtems_semaphore_delete(fs_info->vol_sema);                        
   31dd4:	ebff667b 	bl	b7c8 <rtems_semaphore_delete>                  <== NOT EXECUTED
    free(fs_info->cl_buf);                                            
   31dd8:	e5950098 	ldr	r0, [r5, #152]	; 0x98                         <== NOT EXECUTED
   31ddc:	ebff5634 	bl	76b4 <free>                                    <== NOT EXECUTED
    free(temp_mt_entry->fs_info);                                     
   31de0:	e5940034 	ldr	r0, [r4, #52]	; 0x34                          <== NOT EXECUTED
   31de4:	ebff5632 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
    return rc;                                                        
}                                                                     
   31de8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   31dec:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00002838 <newlib_free_buffers>: */ int newlib_free_buffers( FILE *fp ) {
    2838:	e92d4010 	push	{r4, lr}                                     
    283c:	e1a04000 	mov	r4, r0                                        
  switch ( fileno(fp) ) {                                             
    2840:	eb002bde 	bl	d7c0 <fileno>                                  
    2844:	e3500002 	cmp	r0, #2                                        
    2848:	8a00000b 	bhi	287c <newlib_free_buffers+0x44>               
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
    284c:	e1d430bc 	ldrh	r3, [r4, #12]                                
    2850:	e3130080 	tst	r3, #128	; 0x80                               
    2854:	0a00000a 	beq	2884 <newlib_free_buffers+0x4c>               
        free( fp->_bf._base );                                        
    2858:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    285c:	ebfffd9b 	bl	1ed0 <free>                                    <== NOT EXECUTED
        fp->_flags &= ~__SMBF;                                        
    2860:	e1d420bc 	ldrh	r2, [r4, #12]                                <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
    2864:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
        free( fp->_bf._base );                                        
        fp->_flags &= ~__SMBF;                                        
    2868:	e3c22080 	bic	r2, r2, #128	; 0x80                           <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
    286c:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
        free( fp->_bf._base );                                        
        fp->_flags &= ~__SMBF;                                        
    2870:	e1c420bc 	strh	r2, [r4, #12]                                <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
    2874:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    2878:	ea000001 	b	2884 <newlib_free_buffers+0x4c>                 <== NOT EXECUTED
      }                                                               
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
    287c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    2880:	eb002b1c 	bl	d4f8 <fclose>                                  <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
    2884:	e3a00000 	mov	r0, #0                                        
    2888:	e8bd8010 	pop	{r4, pc}                                      
                                                                      

00002aac <open>: int open( const char *pathname, int flags, ... ) {
    2aac:	e92d000e 	push	{r1, r2, r3}                                 
    2ab0:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
    2ab4:	e24dd01c 	sub	sp, sp, #28                                   
    2ab8:	e59d503c 	ldr	r5, [sp, #60]	; 0x3c                          
  /*                                                                  
   * Set the Evaluation flags                                         
   */                                                                 
                                                                      
  eval_flags = 0;                                                     
  status = flags + 1;                                                 
    2abc:	e2853001 	add	r3, r5, #1                                    
  if ( ( status & _FREAD ) == _FREAD )                                
    2ac0:	e2138001 	ands	r8, r3, #1                                   
    2ac4:	13a08004 	movne	r8, #4                                      
    eval_flags |= RTEMS_LIBIO_PERMS_READ;                             
  if ( ( status & _FWRITE ) == _FWRITE )                              
    2ac8:	e3130002 	tst	r3, #2                                        
    eval_flags |= RTEMS_LIBIO_PERMS_WRITE;                            
                                                                      
                                                                      
  va_start(ap, flags);                                                
                                                                      
  mode = va_arg( ap, int );                                           
    2acc:	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;                            
    2ad0:	13888002 	orrne	r8, r8, #2                                  
int open(                                                             
  const char   *pathname,                                             
  int           flags,                                                
  ...                                                                 
)                                                                     
{                                                                     
    2ad4:	e1a06000 	mov	r6, r0                                        
    eval_flags |= RTEMS_LIBIO_PERMS_WRITE;                            
                                                                      
                                                                      
  va_start(ap, flags);                                                
                                                                      
  mode = va_arg( ap, int );                                           
    2ad8:	e58d3018 	str	r3, [sp, #24]                                 
    2adc:	e59d9040 	ldr	r9, [sp, #64]	; 0x40                          
   *             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();                                       
    2ae0:	eb001e28 	bl	a388 <rtems_libio_allocate>                    
  if ( iop == 0 ) {                                                   
    2ae4:	e2504000 	subs	r4, r0, #0                                   
    2ae8:	03a05017 	moveq	r5, #23                                     
    2aec:	0a000077 	beq	2cd0 <open+0x224>                             
                                                                      
  /*                                                                  
   *  See if the file exists.                                         
   */                                                                 
                                                                      
  status = rtems_filesystem_evaluate_path(                            
    2af0:	e1a00006 	mov	r0, r6                                        
    2af4:	eb002e37 	bl	e3d8 <strlen>                                  
    2af8:	e28d7004 	add	r7, sp, #4                                    
    2afc:	e1a01000 	mov	r1, r0                                        
    2b00:	e1a02008 	mov	r2, r8                                        
    2b04:	e1a00006 	mov	r0, r6                                        
    2b08:	e3a08001 	mov	r8, #1                                        
    2b0c:	e1a03007 	mov	r3, r7                                        
    2b10:	e58d8000 	str	r8, [sp]                                      
    2b14:	ebfffccf 	bl	1e58 <rtems_filesystem_evaluate_path>          
    pathname, strlen( pathname ), eval_flags, &loc, true );           
                                                                      
  if ( status == -1 ) {                                               
    2b18:	e3700001 	cmn	r0, #1                                        
    2b1c:	1a00001f 	bne	2ba0 <open+0xf4>                              
    if ( errno != ENOENT ) {                                          
    2b20:	eb002a27 	bl	d3c4 <__errno>                                 
    2b24:	e5903000 	ldr	r3, [r0]                                      
    2b28:	e3530002 	cmp	r3, #2                                        
    2b2c:	1a00000a 	bne	2b5c <open+0xb0>                              
      rc = errno;                                                     
      goto done;                                                      
    }                                                                 
                                                                      
    /* If the file does not exist and we are not trying to create it--> error */
    if ( !(flags & O_CREAT) ) {                                       
    2b30:	e215ac02 	ands	sl, r5, #512	; 0x200                         
    2b34:	01a0700a 	moveq	r7, sl                                      
    2b38:	01a05003 	moveq	r5, r3                                      
    2b3c:	0a000056 	beq	2c9c <open+0x1f0>                             
      rc = ENOENT;                                                    
      goto done;                                                      
    }                                                                 
                                                                      
    /* Create the node for the new regular file */                    
    rc = mknod( pathname, S_IFREG | mode, 0LL );                      
    2b40:	e1a00006 	mov	r0, r6                                        
    2b44:	e3891902 	orr	r1, r9, #32768	; 0x8000                       
    2b48:	e3a02000 	mov	r2, #0                                        
    2b4c:	e3a03000 	mov	r3, #0                                        
    2b50:	ebfffdec 	bl	2308 <mknod>                                   
    if ( rc ) {                                                       
    2b54:	e250a000 	subs	sl, r0, #0                                   
    2b58:	0a000003 	beq	2b6c <open+0xc0>                              
      rc = errno;                                                     
    2b5c:	eb002a18 	bl	d3c4 <__errno>                                 
    2b60:	e3a07000 	mov	r7, #0                                        
    2b64:	e5905000 	ldr	r5, [r0]                                      
      goto done;                                                      
    2b68:	ea000049 	b	2c94 <open+0x1e8>                               
    }                                                                 
                                                                      
    /* Sanity check to see if the file name exists after the mknod() */
    status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0x0, &loc, true );
    2b6c:	e1a00006 	mov	r0, r6                                        
    2b70:	eb002e18 	bl	e3d8 <strlen>                                  
    2b74:	e1a03007 	mov	r3, r7                                        
    2b78:	e1a01000 	mov	r1, r0                                        
    2b7c:	e1a0200a 	mov	r2, sl                                        
    2b80:	e1a00006 	mov	r0, r6                                        
    2b84:	e58d8000 	str	r8, [sp]                                      
    2b88:	ebfffcb2 	bl	1e58 <rtems_filesystem_evaluate_path>          
    if ( status != 0 ) {   /* The file did not exist */               
    2b8c:	e3500000 	cmp	r0, #0                                        
    2b90:	11a0700a 	movne	r7, sl                                      
    2b94:	13a0500d 	movne	r5, #13                                     
    2b98:	1a00003f 	bne	2c9c <open+0x1f0>                             
    2b9c:	ea000003 	b	2bb0 <open+0x104>                               
      rc = EACCES;                                                    
      goto done;                                                      
    }                                                                 
                                                                      
  } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {        
    2ba0:	e2053c0a 	and	r3, r5, #2560	; 0xa00                         
    2ba4:	e3530c0a 	cmp	r3, #2560	; 0xa00                             
    2ba8:	03a05011 	moveq	r5, #17                                     
    2bac:	0a00003a 	beq	2c9c <open+0x1f0>                             
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
  iop->file_info  = loc.node_access;                                  
    2bb0:	e28d701c 	add	r7, sp, #28                                   
    2bb4:	e5373018 	ldr	r3, [r7, #-24]!                               
    2bb8:	e5843038 	str	r3, [r4, #56]	; 0x38                          
  /*                                                                  
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
    2bbc:	e59d300c 	ldr	r3, [sp, #12]                                 
  iop->file_info  = loc.node_access;                                  
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
    2bc0:	e1a00005 	mov	r0, r5                                        
  /*                                                                  
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
    2bc4:	e584303c 	str	r3, [r4, #60]	; 0x3c                          
  iop->file_info  = loc.node_access;                                  
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
    2bc8:	e5948014 	ldr	r8, [r4, #20]                                 
    2bcc:	eb001e1a 	bl	a43c <rtems_libio_fcntl_flags>                 
    2bd0:	e180e008 	orr	lr, r0, r8                                    
  iop->pathinfo   = loc;                                              
    2bd4:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         
    2bd8:	e284c018 	add	ip, r4, #24                                   
    2bdc:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
                                                                      
  if ( !iop->handlers || !iop->handlers->open_h ) {                   
    2be0:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
  iop->file_info  = loc.node_access;                                  
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
  iop->pathinfo   = loc;                                              
    2be4:	e5972000 	ldr	r2, [r7]                                      
                                                                      
  if ( !iop->handlers || !iop->handlers->open_h ) {                   
    2be8:	e3530000 	cmp	r3, #0                                        
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
  iop->file_info  = loc.node_access;                                  
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
  iop->pathinfo   = loc;                                              
    2bec:	e58c2000 	str	r2, [ip]                                      
   *  returned by successful path evaluation.                         
   */                                                                 
                                                                      
  iop->handlers   = loc.handlers;                                     
  iop->file_info  = loc.node_access;                                  
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
    2bf0:	e584e014 	str	lr, [r4, #20]                                 
  iop->pathinfo   = loc;                                              
                                                                      
  if ( !iop->handlers || !iop->handlers->open_h ) {                   
    2bf4:	0a000041 	beq	2d00 <open+0x254>                             
    2bf8:	e593c000 	ldr	ip, [r3]                                      
    2bfc:	e35c0000 	cmp	ip, #0                                        
    2c00:	0a00003e 	beq	2d00 <open+0x254>                             
    rc = ENOTSUP;                                                     
    goto done;                                                        
  }                                                                   
                                                                      
  rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );        
    2c04:	e1a01006 	mov	r1, r6                                        
    2c08:	e1a03009 	mov	r3, r9                                        
    2c0c:	e1a00004 	mov	r0, r4                                        
    2c10:	e1a02005 	mov	r2, r5                                        
    2c14:	e1a0e00f 	mov	lr, pc                                        
    2c18:	e12fff1c 	bx	ip                                             
  if ( rc ) {                                                         
    2c1c:	e3500000 	cmp	r0, #0                                        
    2c20:	0a000003 	beq	2c34 <open+0x188>                             
    rc = errno;                                                       
    2c24:	eb0029e6 	bl	d3c4 <__errno>                                 
    2c28:	e28d7004 	add	r7, sp, #4                                    
    2c2c:	e5905000 	ldr	r5, [r0]                                      
    goto done;                                                        
    2c30:	ea000017 	b	2c94 <open+0x1e8>                               
                                                                      
  /*                                                                  
   *  Optionally truncate the file.                                   
   */                                                                 
                                                                      
  if ( (flags & O_TRUNC) == O_TRUNC ) {                               
    2c34:	e3150b01 	tst	r5, #1024	; 0x400                             
    2c38:	0a000028 	beq	2ce0 <open+0x234>                             
    rc = ftruncate( iop - rtems_libio_iops, 0 );                      
    2c3c:	e59f30c8 	ldr	r3, [pc, #200]	; 2d0c <open+0x260>            
    2c40:	e5930000 	ldr	r0, [r3]                                      
    2c44:	e0600004 	rsb	r0, r0, r4                                    
    2c48:	e1a00340 	asr	r0, r0, #6                                    
    2c4c:	e3a01000 	mov	r1, #0                                        
    2c50:	e3a02000 	mov	r2, #0                                        
    2c54:	eb001d26 	bl	a0f4 <ftruncate>                               
    if ( rc ) {                                                       
    2c58:	e2505000 	subs	r5, r0, #0                                   
    2c5c:	0a00001f 	beq	2ce0 <open+0x234>                             
      if(errno) rc = errno;                                           
    2c60:	eb0029d7 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    2c64:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
    2c68:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    2c6c:	0a000001 	beq	2c78 <open+0x1cc>                             <== NOT EXECUTED
    2c70:	eb0029d3 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    2c74:	e5905000 	ldr	r5, [r0]                                      <== NOT EXECUTED
      close( iop - rtems_libio_iops );                                
    2c78:	e59f308c 	ldr	r3, [pc, #140]	; 2d0c <open+0x260>            <== NOT EXECUTED
    2c7c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    2c80:	e0634004 	rsb	r4, r3, r4                                    <== NOT EXECUTED
    2c84:	e1a00344 	asr	r0, r4, #6                                    <== NOT EXECUTED
    2c88:	eb001cf0 	bl	a050 <close>                                   <== NOT EXECUTED
    2c8c:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    2c90:	e1a07004 	mov	r7, r4                                        <== NOT EXECUTED
   */                                                                 
                                                                      
done:                                                                 
  va_end(ap);                                                         
                                                                      
  if ( rc ) {                                                         
    2c94:	e3550000 	cmp	r5, #0                                        
    2c98:	0a000010 	beq	2ce0 <open+0x234>                             
    if ( iop )                                                        
    2c9c:	e3540000 	cmp	r4, #0                                        
      rtems_libio_free( iop );                                        
    2ca0:	11a00004 	movne	r0, r4                                      
    2ca4:	1b001da0 	blne	a32c <rtems_libio_free>                      
    if ( loc_to_free )                                                
    2ca8:	e3570000 	cmp	r7, #0                                        
    2cac:	0a000007 	beq	2cd0 <open+0x224>                             
      rtems_filesystem_freenode( loc_to_free );                       
    2cb0:	e597300c 	ldr	r3, [r7, #12]                                 
    2cb4:	e3530000 	cmp	r3, #0                                        
    2cb8:	0a000004 	beq	2cd0 <open+0x224>                             
    2cbc:	e593301c 	ldr	r3, [r3, #28]                                 
    2cc0:	e3530000 	cmp	r3, #0                                        
    2cc4:	11a00007 	movne	r0, r7                                      
    2cc8:	11a0e00f 	movne	lr, pc                                      
    2ccc:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( rc );                       
    2cd0:	eb0029bb 	bl	d3c4 <__errno>                                 
    2cd4:	e5805000 	str	r5, [r0]                                      
    2cd8:	e3e00000 	mvn	r0, #0                                        
    2cdc:	ea000003 	b	2cf0 <open+0x244>                               
  }                                                                   
                                                                      
  return iop - rtems_libio_iops;                                      
    2ce0:	e59f3024 	ldr	r3, [pc, #36]	; 2d0c <open+0x260>             
    2ce4:	e5930000 	ldr	r0, [r3]                                      
    2ce8:	e0604004 	rsb	r4, r0, r4                                    
    2cec:	e1a00344 	asr	r0, r4, #6                                    
}                                                                     
    2cf0:	e28dd01c 	add	sp, sp, #28                                   
    2cf4:	e8bd47f0 	pop	{r4, r5, r6, r7, r8, r9, sl, lr}              
    2cf8:	e28dd00c 	add	sp, sp, #12                                   
    2cfc:	e12fff1e 	bx	lr                                             
    if ( loc_to_free )                                                
      rtems_filesystem_freenode( loc_to_free );                       
    rtems_set_errno_and_return_minus_one( rc );                       
  }                                                                   
                                                                      
  return iop - rtems_libio_iops;                                      
    2d00:	e28d7004 	add	r7, sp, #4                                    <== NOT EXECUTED
    2d04:	e3a05086 	mov	r5, #134	; 0x86                               <== NOT EXECUTED
    2d08:	eaffffe3 	b	2c9c <open+0x1f0>                               <== NOT EXECUTED
                                                                      

00002a48 <open_dev_console>: int stderr_fd; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
    2a48:	e3a01000 	mov	r1, #0                                        
                                                                      
/*                                                                    
 *  This is a replaceable stub which opens the console, if present.   
 */                                                                   
void open_dev_console(void)                                           
{                                                                     
    2a4c:	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) {         
    2a50:	e59f0048 	ldr	r0, [pc, #72]	; 2aa0 <open_dev_console+0x58>  
    2a54:	e1a02001 	mov	r2, r1                                        
    2a58:	eb000013 	bl	2aac <open>                                    
    2a5c:	e3700001 	cmn	r0, #1                                        
    2a60:	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)          
    2a64:	e59f0034 	ldr	r0, [pc, #52]	; 2aa0 <open_dev_console+0x58>  
    2a68:	e3a01001 	mov	r1, #1                                        
    2a6c:	e3a02000 	mov	r2, #0                                        
    2a70:	eb00000d 	bl	2aac <open>                                    
    2a74:	e3700001 	cmn	r0, #1                                        
    rtems_fatal_error_occurred( 0x55544431 );  /* error STD1 */       
    2a78:	059f0024 	ldreq	r0, [pc, #36]	; 2aa4 <open_dev_console+0x5c>
                                                                      
  /*                                                                  
   *  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)          
    2a7c:	0a000006 	beq	2a9c <open_dev_console+0x54>                  
    rtems_fatal_error_occurred( 0x55544431 );  /* error STD1 */       
                                                                      
  if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)          
    2a80:	e59f0018 	ldr	r0, [pc, #24]	; 2aa0 <open_dev_console+0x58>  
    2a84:	e3a01001 	mov	r1, #1                                        
    2a88:	e3a02000 	mov	r2, #0                                        
    2a8c:	eb000006 	bl	2aac <open>                                    
    2a90:	e3700001 	cmn	r0, #1                                        
    2a94:	149df004 	popne	{pc}		; (ldrne pc, [sp], #4)                
    rtems_fatal_error_occurred( 0x55544432 );  /* error STD2 */       
    2a98:	e59f0008 	ldr	r0, [pc, #8]	; 2aa8 <open_dev_console+0x60>   <== NOT EXECUTED
    2a9c:	eb000b41 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

00003448 <oproc>: /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) {
    3448:	e92d4011 	push	{r0, r4, lr}                                 
	int	i;                                                               
                                                                      
	if (tty->termios.c_oflag & OPOST) {                                  
    344c:	e5913034 	ldr	r3, [r1, #52]	; 0x34                          
    3450:	e3130001 	tst	r3, #1                                        
/*                                                                    
 * Handle output processing                                           
 */                                                                   
static void                                                           
oproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
    3454:	e1a04001 	mov	r4, r1                                        
    3458:	e5cd0000 	strb	r0, [sp]                                     
	int	i;                                                               
                                                                      
	if (tty->termios.c_oflag & OPOST) {                                  
    345c:	0a000047 	beq	3580 <oproc+0x138>                            
		switch (c) {                                                        
    3460:	e5dd2000 	ldrb	r2, [sp]                                     
    3464:	e2421008 	sub	r1, r2, #8                                    
    3468:	e3510005 	cmp	r1, #5                                        
    346c:	979ff101 	ldrls	pc, [pc, r1, lsl #2]                        
    3470:	ea00002e 	b	3530 <oproc+0xe8>                               
    3474:	0000351c 	.word	0x0000351c                                  
    3478:	000034f0 	.word	0x000034f0                                  
    347c:	0000348c 	.word	0x0000348c                                  
    3480:	00003530 	.word	0x00003530                                  
    3484:	00003530 	.word	0x00003530                                  
    3488:	000034b8 	.word	0x000034b8                                  
		case '\n':                                                          
			if (tty->termios.c_oflag & ONLRET)                                 
    348c:	e3130020 	tst	r3, #32                                       
				tty->column = 0;                                                  
    3490:	13a03000 	movne	r3, #0                                      
    3494:	15843028 	strne	r3, [r4, #40]	; 0x28                        
			if (tty->termios.c_oflag & ONLCR) {                                
    3498:	e5943034 	ldr	r3, [r4, #52]	; 0x34                          
    349c:	e3130004 	tst	r3, #4                                        
    34a0:	0a000036 	beq	3580 <oproc+0x138>                            
				rtems_termios_puts ("\r", 1, tty);                                
    34a4:	e59f00e8 	ldr	r0, [pc, #232]	; 3594 <oproc+0x14c>           
    34a8:	e3a01001 	mov	r1, #1                                        
    34ac:	e1a02004 	mov	r2, r4                                        
    34b0:	ebffffa3 	bl	3344 <rtems_termios_puts>                      
    34b4:	ea00000b 	b	34e8 <oproc+0xa0>                               
				tty->column = 0;                                                  
			}                                                                  
			break;                                                             
                                                                      
		case '\r':                                                          
			if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))          
    34b8:	e3130010 	tst	r3, #16                                       <== NOT EXECUTED
    34bc:	0a000002 	beq	34cc <oproc+0x84>                             <== NOT EXECUTED
    34c0:	e5942028 	ldr	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
    34c4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    34c8:	0a000030 	beq	3590 <oproc+0x148>                            <== NOT EXECUTED
				return;                                                           
			if (tty->termios.c_oflag & OCRNL) {                                
    34cc:	e2132008 	ands	r2, r3, #8                                   <== NOT EXECUTED
				c = '\n';                                                         
				if (tty->termios.c_oflag & ONLRET)                                
					tty->column = 0;                                                 
				break;                                                            
			}                                                                  
			tty->column = 0;                                                   
    34d0:	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) {                                
    34d4:	0a000029 	beq	3580 <oproc+0x138>                            <== NOT EXECUTED
				c = '\n';                                                         
				if (tty->termios.c_oflag & ONLRET)                                
    34d8:	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';                                                         
    34dc:	e3a0300a 	mov	r3, #10                                       <== NOT EXECUTED
    34e0:	e5cd3000 	strb	r3, [sp]                                     <== NOT EXECUTED
				if (tty->termios.c_oflag & ONLRET)                                
    34e4:	0a000025 	beq	3580 <oproc+0x138>                            <== NOT EXECUTED
					tty->column = 0;                                                 
    34e8:	e3a03000 	mov	r3, #0                                        
    34ec:	ea000022 	b	357c <oproc+0x134>                              
			}                                                                  
			tty->column = 0;                                                   
			break;                                                             
                                                                      
		case '\t':                                                          
			i = 8 - (tty->column & 7);                                         
    34f0:	e5942028 	ldr	r2, [r4, #40]	; 0x28                          
			if ((tty->termios.c_oflag & TABDLY) == XTABS) {                    
    34f4:	e2033b06 	and	r3, r3, #6144	; 0x1800                        
			}                                                                  
			tty->column = 0;                                                   
			break;                                                             
                                                                      
		case '\t':                                                          
			i = 8 - (tty->column & 7);                                         
    34f8:	e2021007 	and	r1, r2, #7                                    
			if ((tty->termios.c_oflag & TABDLY) == XTABS) {                    
    34fc:	e3530b06 	cmp	r3, #6144	; 0x1800                            
			}                                                                  
			tty->column = 0;                                                   
			break;                                                             
                                                                      
		case '\t':                                                          
			i = 8 - (tty->column & 7);                                         
    3500:	e2611008 	rsb	r1, r1, #8                                    
    3504:	e0813002 	add	r3, r1, r2                                    
			if ((tty->termios.c_oflag & TABDLY) == XTABS) {                    
    3508:	1a00001b 	bne	357c <oproc+0x134>                            
				tty->column += i;                                                 
    350c:	e5843028 	str	r3, [r4, #40]	; 0x28                          
				rtems_termios_puts ( "        ",  i, tty);                        
    3510:	e1a02004 	mov	r2, r4                                        
    3514:	e59f007c 	ldr	r0, [pc, #124]	; 3598 <oproc+0x150>           
    3518:	ea00001b 	b	358c <oproc+0x144>                              
			}                                                                  
			tty->column += i;                                                  
			break;                                                             
                                                                      
		case '\b':                                                          
			if (tty->column > 0)                                               
    351c:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    3520:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
				tty->column--;                                                    
    3524:	c2433001 	subgt	r3, r3, #1                                  <== NOT EXECUTED
			}                                                                  
			tty->column += i;                                                  
			break;                                                             
                                                                      
		case '\b':                                                          
			if (tty->column > 0)                                               
    3528:	ca000013 	bgt	357c <oproc+0x134>                            <== NOT EXECUTED
    352c:	ea000013 	b	3580 <oproc+0x138>                              <== NOT EXECUTED
				tty->column--;                                                    
			break;                                                             
                                                                      
		default:                                                            
			if (tty->termios.c_oflag & OLCUC)                                  
    3530:	e3130002 	tst	r3, #2                                        
    3534:	0a000007 	beq	3558 <oproc+0x110>                            
				c = toupper(c);                                                   
    3538:	e59f305c 	ldr	r3, [pc, #92]	; 359c <oproc+0x154>            <== NOT EXECUTED
    353c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    3540:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
    3544:	e5d33001 	ldrb	r3, [r3, #1]                                 <== NOT EXECUTED
    3548:	e2033003 	and	r3, r3, #3                                    <== NOT EXECUTED
    354c:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
    3550:	02422020 	subeq	r2, r2, #32                                 <== NOT EXECUTED
    3554:	e5cd2000 	strb	r2, [sp]                                     <== NOT EXECUTED
			if (!iscntrl(c))                                                   
    3558:	e59f303c 	ldr	r3, [pc, #60]	; 359c <oproc+0x154>            
    355c:	e5932000 	ldr	r2, [r3]                                      
    3560:	e5dd3000 	ldrb	r3, [sp]                                     
    3564:	e0823003 	add	r3, r2, r3                                    
    3568:	e5d33001 	ldrb	r3, [r3, #1]                                 
    356c:	e3130020 	tst	r3, #32                                       
    3570:	1a000002 	bne	3580 <oproc+0x138>                            
				tty->column++;                                                    
    3574:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
    3578:	e2833001 	add	r3, r3, #1                                    
    357c:	e5843028 	str	r3, [r4, #40]	; 0x28                          
			break;                                                             
		}                                                                   
	}                                                                    
	rtems_termios_puts (&c, 1, tty);                                     
    3580:	e1a02004 	mov	r2, r4                                        
    3584:	e1a0000d 	mov	r0, sp                                        
    3588:	e3a01001 	mov	r1, #1                                        
    358c:	ebffff6c 	bl	3344 <rtems_termios_puts>                      
}                                                                     
    3590:	e8bd8018 	pop	{r3, r4, pc}                                  
                                                                      

0000c590 <pipe_create>: * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) {
    c590:	e92d4070 	push	{r4, r5, r6, lr}                             
    c594:	e24dd028 	sub	sp, sp, #40	; 0x28                            
  rtems_filesystem_location_info_t loc;                               
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
  /* Create /tmp if not exists */                                     
  if (rtems_filesystem_evaluate_path("/tmp", 3, RTEMS_LIBIO_PERMS_RWX, &loc, TRUE)
    c598:	e28d5004 	add	r5, sp, #4                                    
    c59c:	e3a0c001 	mov	ip, #1                                        
 * Called by pipe() to create an anonymous pipe.                      
 */                                                                   
int pipe_create(                                                      
  int filsdes[2]                                                      
)                                                                     
{                                                                     
    c5a0:	e1a04000 	mov	r4, r0                                        
  rtems_filesystem_location_info_t loc;                               
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
  /* Create /tmp if not exists */                                     
  if (rtems_filesystem_evaluate_path("/tmp", 3, RTEMS_LIBIO_PERMS_RWX, &loc, TRUE)
    c5a4:	e3a01003 	mov	r1, #3                                        
    c5a8:	e59f0140 	ldr	r0, [pc, #320]	; c6f0 <pipe_create+0x160>     
    c5ac:	e3a02007 	mov	r2, #7                                        
    c5b0:	e1a03005 	mov	r3, r5                                        
    c5b4:	e58dc000 	str	ip, [sp]                                      
    c5b8:	ebffd626 	bl	1e58 <rtems_filesystem_evaluate_path>          
    c5bc:	e3500000 	cmp	r0, #0                                        
    c5c0:	0a000009 	beq	c5ec <pipe_create+0x5c>                       
      != 0) {                                                         
    if (errno != ENOENT)                                              
    c5c4:	eb00037e 	bl	d3c4 <__errno>                                 
    c5c8:	e5903000 	ldr	r3, [r0]                                      
    c5cc:	e3530002 	cmp	r3, #2                                        
    c5d0:	1a000043 	bne	c6e4 <pipe_create+0x154>                      
      return -1;                                                      
    if (mkdir("/tmp", S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX) != 0)          
    c5d4:	e59f0114 	ldr	r0, [pc, #276]	; c6f0 <pipe_create+0x160>     
    c5d8:	e59f1114 	ldr	r1, [pc, #276]	; c6f4 <pipe_create+0x164>     
    c5dc:	ebffd745 	bl	22f8 <mkdir>                                   
    c5e0:	e3500000 	cmp	r0, #0                                        
    c5e4:	0a000008 	beq	c60c <pipe_create+0x7c>                       
    c5e8:	ea00003d 	b	c6e4 <pipe_create+0x154>                        <== NOT EXECUTED
      return -1;                                                      
  }                                                                   
  else                                                                
    rtems_filesystem_freenode(&loc);                                  
    c5ec:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
    c5f0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    c5f4:	0a000004 	beq	c60c <pipe_create+0x7c>                       <== NOT EXECUTED
    c5f8:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    c5fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    c600:	11a00005 	movne	r0, r5                                      <== NOT EXECUTED
    c604:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    c608:	112fff13 	bxne	r3                                           <== NOT EXECUTED
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
    c60c:	e28d5018 	add	r5, sp, #24                                   
    c610:	e59f10e0 	ldr	r1, [pc, #224]	; c6f8 <pipe_create+0x168>     
    c614:	e3a0200a 	mov	r2, #10                                       
    c618:	e1a00005 	mov	r0, r5                                        
    c61c:	eb000576 	bl	dbfc <memcpy>                                  
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
    c620:	e59f30d4 	ldr	r3, [pc, #212]	; c6fc <pipe_create+0x16c>     
    c624:	e1d3c0b0 	ldrh	ip, [r3]                                     
    c628:	e1a0200c 	mov	r2, ip                                        
    c62c:	e28cc001 	add	ip, ip, #1                                    
    c630:	e59f10c8 	ldr	r1, [pc, #200]	; c700 <pipe_create+0x170>     
    c634:	e1c3c0b0 	strh	ip, [r3]                                     
    c638:	e285000a 	add	r0, r5, #10                                   
    c63c:	eb000614 	bl	de94 <sprintf>                                 
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
    c640:	e1a00005 	mov	r0, r5                                        
    c644:	e3a01d06 	mov	r1, #384	; 0x180                              
    c648:	eb000190 	bl	cc90 <mkfifo>                                  
    c64c:	e2506000 	subs	r6, r0, #0                                   
    c650:	0a000001 	beq	c65c <pipe_create+0xcc>                       
    if (errno != EEXIST){                                             
    c654:	eb00035a 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    c658:	ea000021 	b	c6e4 <pipe_create+0x154>                        <== 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);                 
    c65c:	e1a00005 	mov	r0, r5                                        
    c660:	e3a01901 	mov	r1, #16384	; 0x4000                           
    c664:	ebffd910 	bl	2aac <open>                                    
  if (filsdes[0] < 0) {                                               
    c668:	e3500000 	cmp	r0, #0                                        
    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);                 
    c66c:	e5840000 	str	r0, [r4]                                      
  if (filsdes[0] < 0) {                                               
    c670:	aa000003 	bge	c684 <pipe_create+0xf4>                       
    err = errno;                                                      
    c674:	eb000352 	bl	d3c4 <__errno>                                 
    c678:	e5906000 	ldr	r6, [r0]                                      
    /* 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);                                                 
    c67c:	e1a00005 	mov	r0, r5                                        
    c680:	ea000014 	b	c6d8 <pipe_create+0x148>                        
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
    c684:	e59f3078 	ldr	r3, [pc, #120]	; c704 <pipe_create+0x174>     <== NOT EXECUTED
    c688:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    c68c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    c690:	359f3070 	ldrcc	r3, [pc, #112]	; c708 <pipe_create+0x178>   <== NOT EXECUTED
    c694:	35936000 	ldrcc	r6, [r3]                                    <== NOT EXECUTED
    c698:	30866300 	addcc	r6, r6, r0, lsl #6                          <== NOT EXECUTED
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
    c69c:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
    c6a0:	e3c33001 	bic	r3, r3, #1                                    <== NOT EXECUTED
    c6a4:	e5863014 	str	r3, [r6, #20]                                 <== NOT EXECUTED
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
    c6a8:	e28d0018 	add	r0, sp, #24                                   <== NOT EXECUTED
    c6ac:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    c6b0:	ebffd8fd 	bl	2aac <open>                                    <== NOT EXECUTED
                                                                      
    if (filsdes[1] < 0) {                                             
    c6b4:	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);                            
    c6b8:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
                                                                      
    if (filsdes[1] < 0) {                                             
    c6bc:	a3a06000 	movge	r6, #0                                      <== NOT EXECUTED
    c6c0:	aa000003 	bge	c6d4 <pipe_create+0x144>                      <== NOT EXECUTED
    err = errno;                                                      
    c6c4:	eb00033e 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    c6c8:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
    close(filsdes[0]);                                                
    c6cc:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
    c6d0:	ebfff65e 	bl	a050 <close>                                   <== NOT EXECUTED
    }                                                                 
  unlink(fifopath);                                                   
    c6d4:	e28d0018 	add	r0, sp, #24                                   <== NOT EXECUTED
    c6d8:	eb000170 	bl	cca0 <unlink>                                  
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one(err);                          
    c6dc:	eb000338 	bl	d3c4 <__errno>                                 
    c6e0:	e5806000 	str	r6, [r0]                                      
}                                                                     
    c6e4:	e3e00000 	mvn	r0, #0                                        
    c6e8:	e28dd028 	add	sp, sp, #40	; 0x28                            
    c6ec:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00008b84 <pipe_free>: /* Called with rtems_pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) {
    8b84:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
    8b88:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_barrier_delete(pipe->readBarrier);                            
    8b8c:	e590002c 	ldr	r0, [r0, #44]	; 0x2c                          <== NOT EXECUTED
    8b90:	eb000713 	bl	a7e4 <rtems_barrier_delete>                    <== NOT EXECUTED
  rtems_barrier_delete(pipe->writeBarrier);                           
    8b94:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
    8b98:	eb000711 	bl	a7e4 <rtems_barrier_delete>                    <== NOT EXECUTED
  rtems_semaphore_delete(pipe->Semaphore);                            
    8b9c:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8ba0:	ebfff156 	bl	5100 <rtems_semaphore_delete>                  <== NOT EXECUTED
  free(pipe->Buffer);                                                 
    8ba4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
    8ba8:	ebffe4c8 	bl	1ed0 <free>                                    <== NOT EXECUTED
  free(pipe);                                                         
    8bac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
    8bb0:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
{                                                                     
  rtems_barrier_delete(pipe->readBarrier);                            
  rtems_barrier_delete(pipe->writeBarrier);                           
  rtems_semaphore_delete(pipe->Semaphore);                            
  free(pipe->Buffer);                                                 
  free(pipe);                                                         
    8bb4:	eaffe4c5 	b	1ed0 <free>                                     <== NOT EXECUTED
                                                                      

00008824 <pipe_ioctl>: uint32_t cmd, void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) {
    8824:	e59f3054 	ldr	r3, [pc, #84]	; 8880 <pipe_ioctl+0x5c>        <== NOT EXECUTED
    8828:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  uint32_t        cmd,                                                
  void           *buffer,                                             
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
    882c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
    8830:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    8834:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  if (cmd == FIONREAD) {                                              
    8838:	13e00015 	mvnne	r0, #21                                     <== NOT EXECUTED
    883c:	18bd8070 	popne	{r4, r5, r6, pc}                            <== NOT EXECUTED
    if (buffer == NULL)                                               
    8840:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    8844:	03e0000d 	mvneq	r0, #13                                     <== NOT EXECUTED
    8848:	08bd8070 	popeq	{r4, r5, r6, pc}                            <== NOT EXECUTED
      return -EFAULT;                                                 
                                                                      
    if (! PIPE_LOCK(pipe))                                            
    884c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    8850:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8854:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    8858:	ebfff24f 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    885c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    8860:	13e00003 	mvnne	r0, #3                                      <== NOT EXECUTED
    8864:	18bd8070 	popne	{r4, r5, r6, pc}                            <== NOT EXECUTED
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
    8868:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
    PIPE_UNLOCK(pipe);                                                
    886c:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
    if (! PIPE_LOCK(pipe))                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
    8870:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
    PIPE_UNLOCK(pipe);                                                
    8874:	ebfff28e 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
    8878:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    return 0;                                                         
  }                                                                   
                                                                      
  return -EINVAL;                                                     
}                                                                     
    887c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

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

00008a14 <pipe_read>: pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) {
    8a14:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
    8a18:	e1a09001 	mov	r9, r1                                        <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    8a1c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  void           *buffer,                                             
  size_t          count,                                              
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
    8a20:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    8a24:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    8a28:	e5900028 	ldr	r0, [r0, #40]	; 0x28                          <== NOT EXECUTED
    8a2c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  void           *buffer,                                             
  size_t          count,                                              
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
    8a30:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    8a34:	ebfff1d8 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    8a38:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    8a3c:	13e06003 	mvnne	r6, #3                                      <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
      pipe->Start = 0;                                                
                                                                      
    if (pipe->waitingWriters > 0)                                     
      PIPE_WAKEUPWRITERS(pipe);                                       
    8a40:	01a0b00d 	moveq	fp, sp                                      <== NOT EXECUTED
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    8a44:	0a000045 	beq	8b60 <pipe_read+0x14c>                        <== NOT EXECUTED
    8a48:	ea00004b 	b	8b7c <pipe_read+0x168>                          <== NOT EXECUTED
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
    while (PIPE_EMPTY(pipe)) {                                        
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
    8a4c:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
    8a50:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8a54:	0a000043 	beq	8b68 <pipe_read+0x154>                        <== NOT EXECUTED
        goto out_locked;                                              
                                                                      
      if (LIBIO_NODELAY(iop)) {                                       
    8a58:	e59a7014 	ldr	r7, [sl, #20]                                 <== NOT EXECUTED
    8a5c:	e2177001 	ands	r7, r7, #1                                   <== NOT EXECUTED
    8a60:	13e0700a 	mvnne	r7, #10                                     <== NOT EXECUTED
    8a64:	1a000040 	bne	8b6c <pipe_read+0x158>                        <== NOT EXECUTED
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
    8a68:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
    8a6c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
    8a70:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
    8a74:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8a78:	ebfff20d 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
      if (! PIPE_READWAIT(pipe))                                      
    8a7c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    8a80:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
    8a84:	eb000784 	bl	a89c <rtems_barrier_wait>                      <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
    8a88:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    8a8c:	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))                                      
    8a90:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
    8a94:	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))                                      
    8a98:	13e07003 	mvnne	r7, #3                                      <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
    8a9c:	ebfff1be 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    8aa0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8aa4:	13e07003 	mvnne	r7, #3                                      <== NOT EXECUTED
    8aa8:	1a000031 	bne	8b74 <pipe_read+0x160>                        <== NOT EXECUTED
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
    8aac:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
    8ab0:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
    8ab4:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    8ab8:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
    8abc:	1a00002a 	bne	8b6c <pipe_read+0x158>                        <== NOT EXECUTED
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
    while (PIPE_EMPTY(pipe)) {                                        
    8ac0:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
    8ac4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    8ac8:	0affffdf 	beq	8a4c <pipe_read+0x38>                         <== NOT EXECUTED
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
    chunk1 = pipe->Size - pipe->Start;                                
    8acc:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
    8ad0:	e5948004 	ldr	r8, [r4, #4]                                  <== NOT EXECUTED
      if (ret != 0)                                                   
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
    8ad4:	e0667005 	rsb	r7, r6, r5                                    <== NOT EXECUTED
    8ad8:	e1520007 	cmp	r2, r7                                        <== NOT EXECUTED
    8adc:	31a07002 	movcc	r7, r2                                      <== NOT EXECUTED
    chunk1 = pipe->Size - pipe->Start;                                
    8ae0:	e0638008 	rsb	r8, r3, r8                                    <== NOT EXECUTED
    8ae4:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
    if (chunk > chunk1) {                                             
    8ae8:	e1570008 	cmp	r7, r8                                        <== NOT EXECUTED
    8aec:	e0890006 	add	r0, r9, r6                                    <== 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);       
    8af0:	d0811003 	addle	r1, r1, r3                                  <== NOT EXECUTED
    8af4:	d1a02007 	movle	r2, r7                                      <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
    chunk1 = pipe->Size - pipe->Start;                                
    if (chunk > chunk1) {                                             
    8af8:	da000006 	ble	8b18 <pipe_read+0x104>                        <== NOT EXECUTED
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);      
    8afc:	e0811003 	add	r1, r1, r3                                    <== NOT EXECUTED
    8b00:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
    8b04:	eb00143c 	bl	dbfc <memcpy>                                  <== NOT EXECUTED
      memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);   
    8b08:	e0860008 	add	r0, r6, r8                                    <== NOT EXECUTED
    8b0c:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
    8b10:	e0890000 	add	r0, r9, r0                                    <== NOT EXECUTED
    8b14:	e0682007 	rsb	r2, r8, r7                                    <== NOT EXECUTED
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
    8b18:	eb001437 	bl	dbfc <memcpy>                                  <== NOT EXECUTED
                                                                      
    pipe->Start += chunk;                                             
    8b1c:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    8b20:	e0870000 	add	r0, r7, r0                                    <== NOT EXECUTED
    8b24:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
    pipe->Start %= pipe->Size;                                        
    8b28:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
    8b2c:	eb003842 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    pipe->Length -= chunk;                                            
    8b30:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
    8b34:	e0673003 	rsb	r3, r7, r3                                    <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
    8b38:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
    pipe->Start %= pipe->Size;                                        
    8b3c:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
    pipe->Length -= chunk;                                            
    8b40:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
      pipe->Start = 0;                                                
    8b44:	05843008 	streq	r3, [r4, #8]                                <== NOT EXECUTED
                                                                      
    if (pipe->waitingWriters > 0)                                     
    8b48:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
    8b4c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      PIPE_WAKEUPWRITERS(pipe);                                       
    8b50:	15940030 	ldrne	r0, [r4, #48]	; 0x30                        <== NOT EXECUTED
    8b54:	11a0100d 	movne	r1, sp                                      <== NOT EXECUTED
    8b58:	1b000739 	blne	a844 <rtems_barrier_release>                 <== NOT EXECUTED
    read += chunk;                                                    
    8b5c:	e0866007 	add	r6, r6, r7                                    <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
    8b60:	e1560005 	cmp	r6, r5                                        <== NOT EXECUTED
    8b64:	3affffd5 	bcc	8ac0 <pipe_read+0xac>                         <== NOT EXECUTED
    8b68:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
    8b6c:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8b70:	ebfff1cf 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
                                                                      
out_nolock:                                                           
  if (read > 0)                                                       
    8b74:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    8b78:	d1a06007 	movle	r6, r7                                      <== NOT EXECUTED
    return read;                                                      
  return ret;                                                         
}                                                                     
    8b7c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    8b80:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

00008bb8 <pipe_release>: */ int pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) {
    8bb8:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
  pipe_control_t *pipe = *pipep;                                      
    8bbc:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
 */                                                                   
int pipe_release(                                                     
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
    8bc0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  pipe_control_t *pipe = *pipep;                                      
  uint32_t mode;                                                      
                                                                      
  rtems_status_code sc;                                               
  sc = rtems_semaphore_obtain(pipe->Semaphore,                        
    8bc4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 */                                                                   
int pipe_release(                                                     
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
    8bc8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  pipe_control_t *pipe = *pipep;                                      
  uint32_t mode;                                                      
                                                                      
  rtems_status_code sc;                                               
  sc = rtems_semaphore_obtain(pipe->Semaphore,                        
    8bcc:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    8bd0:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8bd4:	ebfff170 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
                              RTEMS_WAIT, RTEMS_NO_TIMEOUT);          
  /* WARN pipe not released! */                                       
  if(sc != RTEMS_SUCCESSFUL)                                          
    8bd8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8bdc:	1a000010 	bne	8c24 <pipe_release+0x6c>                      <== NOT EXECUTED
    rtems_fatal_error_occurred(sc);                                   
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
    8be0:	e5955014 	ldr	r5, [r5, #20]                                 <== NOT EXECUTED
  if (mode & LIBIO_FLAGS_READ)                                        
    8be4:	e3150002 	tst	r5, #2                                        <== NOT EXECUTED
     pipe->Readers --;                                                
    8be8:	15943010 	ldrne	r3, [r4, #16]                               <== NOT EXECUTED
                              RTEMS_WAIT, RTEMS_NO_TIMEOUT);          
  /* WARN pipe not released! */                                       
  if(sc != RTEMS_SUCCESSFUL)                                          
    rtems_fatal_error_occurred(sc);                                   
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
    8bec:	e2055006 	and	r5, r5, #6                                    <== NOT EXECUTED
  if (mode & LIBIO_FLAGS_READ)                                        
     pipe->Readers --;                                                
    8bf0:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
    8bf4:	15843010 	strne	r3, [r4, #16]                               <== NOT EXECUTED
  if (mode & LIBIO_FLAGS_WRITE)                                       
    8bf8:	e3150004 	tst	r5, #4                                        <== NOT EXECUTED
     pipe->Writers --;                                                
    8bfc:	15943014 	ldrne	r3, [r4, #20]                               <== NOT EXECUTED
    8c00:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
    8c04:	15843014 	strne	r3, [r4, #20]                               <== NOT EXECUTED
                                                                      
  sc = rtems_semaphore_obtain(rtems_pipe_semaphore,                   
    8c08:	e59f30a0 	ldr	r3, [pc, #160]	; 8cb0 <pipe_release+0xf8>     <== NOT EXECUTED
    8c0c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    8c10:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    8c14:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    8c18:	ebfff15f 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
                              RTEMS_WAIT, RTEMS_NO_TIMEOUT);          
  /* WARN pipe not freed and pipep not set to NULL! */                
  if(sc != RTEMS_SUCCESSFUL)                                          
    8c1c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8c20:	0a000000 	beq	8c28 <pipe_release+0x70>                      <== NOT EXECUTED
    rtems_fatal_error_occurred(sc);                                   
    8c24:	ebfff2df 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
    8c28:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8c2c:	ebfff1a0 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
    8c30:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
    8c34:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8c38:	1a000006 	bne	8c58 <pipe_release+0xa0>                      <== NOT EXECUTED
    8c3c:	e5947014 	ldr	r7, [r4, #20]                                 <== NOT EXECUTED
    8c40:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    8c44:	1a000003 	bne	8c58 <pipe_release+0xa0>                      <== NOT EXECUTED
#if 0                                                                 
    /* To delete an anonymous pipe file when all users closed it */   
    if (pipe->Anonymous)                                              
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    8c48:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    8c4c:	ebffffcc 	bl	8b84 <pipe_free>                               <== NOT EXECUTED
    *pipep = NULL;                                                    
    8c50:	e5867000 	str	r7, [r6]                                      <== NOT EXECUTED
  if(sc != RTEMS_SUCCESSFUL)                                          
    rtems_fatal_error_occurred(sc);                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
    8c54:	ea000010 	b	8c9c <pipe_release+0xe4>                        <== NOT EXECUTED
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
    8c58:	e2552004 	subs	r2, r5, #4                                   <== NOT EXECUTED
    8c5c:	13a02001 	movne	r2, #1                                      <== NOT EXECUTED
    8c60:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8c64:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
    8c68:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
    8c6c:	15940030 	ldrne	r0, [r4, #48]	; 0x30                        <== NOT EXECUTED
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
    8c70:	1a000007 	bne	8c94 <pipe_release+0xdc>                      <== NOT EXECUTED
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
  else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)            
    8c74:	e5942014 	ldr	r2, [r4, #20]                                 <== NOT EXECUTED
    8c78:	e2553002 	subs	r3, r5, #2                                   <== NOT EXECUTED
    8c7c:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
    8c80:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    8c84:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
    8c88:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8c8c:	0a000002 	beq	8c9c <pipe_release+0xe4>                      <== NOT EXECUTED
    PIPE_WAKEUPREADERS(pipe);                                         
    8c90:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
    8c94:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
    8c98:	eb0006e9 	bl	a844 <rtems_barrier_release>                   <== NOT EXECUTED
                                                                      
  rtems_semaphore_release(rtems_pipe_semaphore);                      
    8c9c:	e59f300c 	ldr	r3, [pc, #12]	; 8cb0 <pipe_release+0xf8>      <== NOT EXECUTED
    8ca0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    8ca4:	ebfff182 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
  if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))                     
    return -errno;                                                    
#endif                                                                
                                                                      
  return 0;                                                           
}                                                                     
    8ca8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    8cac:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      <== NOT EXECUTED
                                                                      

00008884 <pipe_write>: pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) {
    8884:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    8888:	e2525000 	subs	r5, r2, #0                                   <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  const void     *buffer,                                             
  size_t          count,                                              
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
    888c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    8890:	e1a0b001 	mov	fp, r1                                        <== NOT EXECUTED
    8894:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    8898:	01a06005 	moveq	r6, r5                                      <== NOT EXECUTED
    889c:	0a00005a 	beq	8a0c <pipe_write+0x188>                       <== NOT EXECUTED
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    88a0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    88a4:	e5900028 	ldr	r0, [r0, #40]	; 0x28                          <== NOT EXECUTED
    88a8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    88ac:	ebfff23a 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    88b0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    88b4:	13e06003 	mvnne	r6, #3                                      <== NOT EXECUTED
    88b8:	1a000053 	bne	8a0c <pipe_write+0x188>                       <== NOT EXECUTED
    return -EINTR;                                                    
                                                                      
  if (pipe->Readers == 0) {                                           
    88bc:	e5946010 	ldr	r6, [r4, #16]                                 <== NOT EXECUTED
    88c0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    88c4:	0a000022 	beq	8954 <pipe_write+0xd0>                        <== NOT EXECUTED
    ret = -EPIPE;                                                     
    goto out_locked;                                                  
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
    88c8:	e5949004 	ldr	r9, [r4, #4]                                  <== NOT EXECUTED
    88cc:	e1550009 	cmp	r5, r9                                        <== NOT EXECUTED
    88d0:	91a09005 	movls	r9, r5                                      <== NOT EXECUTED
    88d4:	83a09001 	movhi	r9, #1                                      <== NOT EXECUTED
    88d8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    88dc:	ea000043 	b	89f0 <pipe_write+0x16c>                         <== NOT EXECUTED
                                                                      
  while (written < count) {                                           
    while (PIPE_SPACE(pipe) < chunk) {                                
      if (LIBIO_NODELAY(iop)) {                                       
    88e0:	e5987014 	ldr	r7, [r8, #20]                                 <== NOT EXECUTED
    88e4:	e2177001 	ands	r7, r7, #1                                   <== NOT EXECUTED
    88e8:	13e0700a 	mvnne	r7, #10                                     <== NOT EXECUTED
    88ec:	1a000042 	bne	89fc <pipe_write+0x178>                       <== NOT EXECUTED
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
    88f0:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
    88f4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
    88f8:	e584301c 	str	r3, [r4, #28]                                 <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
    88fc:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8900:	ebfff26b 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
      if (! PIPE_WRITEWAIT(pipe))                                     
    8904:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    8908:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
    890c:	eb0007e2 	bl	a89c <rtems_barrier_wait>                      <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
    8910:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    8914:	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))                                     
    8918:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
    891c:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
    8920:	13e07003 	mvnne	r7, #3                                      <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
    8924:	ebfff21c 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    8928:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    892c:	13e07003 	mvnne	r7, #3                                      <== NOT EXECUTED
    8930:	1a000033 	bne	8a04 <pipe_write+0x180>                       <== NOT EXECUTED
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
    8934:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
    8938:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
    893c:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    8940:	e584301c 	str	r3, [r4, #28]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
    8944:	1a00002c 	bne	89fc <pipe_write+0x178>                       <== NOT EXECUTED
        goto out_locked;                                              
                                                                      
      if (pipe->Readers == 0) {                                       
    8948:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
    894c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8950:	1a000001 	bne	895c <pipe_write+0xd8>                        <== NOT EXECUTED
    8954:	e3e0701f 	mvn	r7, #31                                       <== NOT EXECUTED
    8958:	ea000027 	b	89fc <pipe_write+0x178>                         <== 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) {                                
    895c:	e594a004 	ldr	sl, [r4, #4]                                  <== NOT EXECUTED
    8960:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
    8964:	e062300a 	rsb	r3, r2, sl                                    <== NOT EXECUTED
    8968:	e1530009 	cmp	r3, r9                                        <== NOT EXECUTED
    896c:	3affffdb 	bcc	88e0 <pipe_write+0x5c>                        <== NOT EXECUTED
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
    8970:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    8974:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
    8978:	e0820000 	add	r0, r2, r0                                    <== NOT EXECUTED
        ret = -EPIPE;                                                 
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    897c:	e0667005 	rsb	r7, r6, r5                                    <== NOT EXECUTED
    8980:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
    8984:	31a07003 	movcc	r7, r3                                      <== NOT EXECUTED
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
    8988:	eb0038ab 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    898c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
    8990:	e060a00a 	rsb	sl, r0, sl                                    <== NOT EXECUTED
    if (chunk > chunk1) {                                             
    8994:	e157000a 	cmp	r7, sl                                        <== NOT EXECUTED
    8998:	e08b1006 	add	r1, fp, r6                                    <== NOT EXECUTED
      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);
    899c:	d0830000 	addle	r0, r3, r0                                  <== NOT EXECUTED
    89a0:	d1a02007 	movle	r2, r7                                      <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
    if (chunk > chunk1) {                                             
    89a4:	da000006 	ble	89c4 <pipe_write+0x140>                       <== NOT EXECUTED
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
    89a8:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
    89ac:	e0830000 	add	r0, r3, r0                                    <== NOT EXECUTED
    89b0:	eb001491 	bl	dbfc <memcpy>                                  <== NOT EXECUTED
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    89b4:	e08a1006 	add	r1, sl, r6                                    <== NOT EXECUTED
    89b8:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
    89bc:	e08b1001 	add	r1, fp, r1                                    <== NOT EXECUTED
    89c0:	e06a2007 	rsb	r2, sl, r7                                    <== NOT EXECUTED
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
    89c4:	eb00148c 	bl	dbfc <memcpy>                                  <== NOT EXECUTED
                                                                      
    pipe->Length += chunk;                                            
    89c8:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
    if (pipe->waitingReaders > 0)                                     
    89cc:	e5942018 	ldr	r2, [r4, #24]                                 <== NOT EXECUTED
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
    89d0:	e0833007 	add	r3, r3, r7                                    <== NOT EXECUTED
    if (pipe->waitingReaders > 0)                                     
    89d4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
    89d8:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
    89dc:	1594002c 	ldrne	r0, [r4, #44]	; 0x2c                        <== NOT EXECUTED
    89e0:	11a0100d 	movne	r1, sp                                      <== NOT EXECUTED
    89e4:	1b000796 	blne	a844 <rtems_barrier_release>                 <== NOT EXECUTED
    written += chunk;                                                 
    89e8:	e0866007 	add	r6, r6, r7                                    <== NOT EXECUTED
    89ec:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
    89f0:	e1560005 	cmp	r6, r5                                        <== NOT EXECUTED
    89f4:	3affffd8 	bcc	895c <pipe_write+0xd8>                        <== NOT EXECUTED
    89f8:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
    89fc:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    8a00:	ebfff22b 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
#endif                                                                
                                                                      
  if (written > 0)                                                    
    8a04:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    8a08:	d1a06007 	movle	r6, r7                                      <== NOT EXECUTED
    return written;                                                   
  return ret;                                                         
}                                                                     
    8a0c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    8a10:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

00009aec <ramdisk_allocate>: void *area_begin, uint32_t block_size, rtems_blkdev_bnum block_count, bool trace ) {
    9aec:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
    9af0:	e1a04000 	mov	r4, r0                                        
  struct ramdisk *rd = malloc(sizeof(struct ramdisk));                
    9af4:	e3a00010 	mov	r0, #16                                       
  void *area_begin,                                                   
  uint32_t block_size,                                                
  rtems_blkdev_bnum block_count,                                      
  bool trace                                                          
)                                                                     
{                                                                     
    9af8:	e1a05001 	mov	r5, r1                                        
    9afc:	e1a08002 	mov	r8, r2                                        
    9b00:	e203a0ff 	and	sl, r3, #255	; 0xff                           
  struct ramdisk *rd = malloc(sizeof(struct ramdisk));                
    9b04:	ebffe578 	bl	30ec <malloc>                                  
                                                                      
  if (rd == NULL) {                                                   
    9b08:	e3500000 	cmp	r0, #0                                        
  uint32_t block_size,                                                
  rtems_blkdev_bnum block_count,                                      
  bool trace                                                          
)                                                                     
{                                                                     
  struct ramdisk *rd = malloc(sizeof(struct ramdisk));                
    9b0c:	e1a07000 	mov	r7, r0                                        
    9b10:	e1a06000 	mov	r6, r0                                        
                                                                      
  if (rd == NULL) {                                                   
    9b14:	0a000012 	beq	9b64 <ramdisk_allocate+0x78>                  
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
    9b18:	e3540000 	cmp	r4, #0                                        
                                                                      
      return NULL;                                                    
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
    9b1c:	13a03000 	movne	r3, #0                                      
                                                                      
  if (rd == NULL) {                                                   
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
    9b20:	1a000009 	bne	9b4c <ramdisk_allocate+0x60>                  
    area_begin = calloc(block_count, block_size);                     
    9b24:	e1a00008 	mov	r0, r8                                        
    9b28:	e1a01005 	mov	r1, r5                                        
    9b2c:	ebffe41a 	bl	2b9c <calloc>                                  
    if (area_begin == NULL) {                                         
    9b30:	e2504000 	subs	r4, r0, #0                                   
      free(rd);                                                       
                                                                      
      return NULL;                                                    
    }                                                                 
    rd->malloced = true;                                              
    9b34:	13a03001 	movne	r3, #1                                      
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
    area_begin = calloc(block_count, block_size);                     
    if (area_begin == NULL) {                                         
    9b38:	1a000003 	bne	9b4c <ramdisk_allocate+0x60>                  
      free(rd);                                                       
    9b3c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    9b40:	ebffe49d 	bl	2dbc <free>                                    <== NOT EXECUTED
    9b44:	e1a07004 	mov	r7, r4                                        <== NOT EXECUTED
                                                                      
      return NULL;                                                    
    9b48:	ea000005 	b	9b64 <ramdisk_allocate+0x78>                    <== NOT EXECUTED
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
    9b4c:	e5c6300d 	strb	r3, [r6, #13]                                
  }                                                                   
  rd->block_size = block_size;                                        
  rd->block_num = block_count;                                        
  rd->area = area_begin;                                              
  rd->trace = trace;                                                  
  rd->initialized = true;                                             
    9b50:	e3a03001 	mov	r3, #1                                        
    9b54:	e5c6300c 	strb	r3, [r6, #12]                                
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
  }                                                                   
  rd->block_size = block_size;                                        
    9b58:	e8860120 	stm	r6, {r5, r8}                                  
  rd->block_num = block_count;                                        
  rd->area = area_begin;                                              
    9b5c:	e5864008 	str	r4, [r6, #8]                                  
  rd->trace = trace;                                                  
    9b60:	e5c6a00e 	strb	sl, [r6, #14]                                
  rd->initialized = true;                                             
                                                                      
  return rd;                                                          
}                                                                     
    9b64:	e1a00007 	mov	r0, r7                                        
    9b68:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

0001debc <ramdisk_initialize>: rtems_device_driver ramdisk_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *arg __attribute__((unused))) {
   1debc:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   1dec0:	e24dd02c 	sub	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
   1dec4:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
    rtems_device_minor_number i;                                      
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;            
    struct ramdisk *r;                                                
    rtems_status_code rc;                                             
                                                                      
    rc = rtems_disk_io_initialize();                                  
   1dec8:	ebffa07c 	bl	60c0 <rtems_disk_io_initialize>                <== NOT EXECUTED
    if (rc != RTEMS_SUCCESSFUL)                                       
   1decc:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1ded0:	1a00003d 	bne	1dfcc <ramdisk_initialize+0x110>              <== NOT EXECUTED
     * This is allocating memory for a RAM disk which will persist for
     * the life of the system. RTEMS has no "de-initialize" driver call
     * so there is no corresponding free(r).  Coverity is correct that
     * it is never freed but this is not a problem.                   
     */                                                               
    r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
   1ded4:	e59fa0fc 	ldr	sl, [pc, #252]	; 1dfd8 <ramdisk_initialize+0x11c><== NOT EXECUTED
   1ded8:	e3a01010 	mov	r1, #16                                       <== NOT EXECUTED
   1dedc:	e59a0000 	ldr	r0, [sl]                                      <== NOT EXECUTED
   1dee0:	ebffa483 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    r->trace = false;                                                 
   1dee4:	e59f50f0 	ldr	r5, [pc, #240]	; 1dfdc <ramdisk_initialize+0x120><== NOT EXECUTED
     * This is allocating memory for a RAM disk which will persist for
     * the life of the system. RTEMS has no "de-initialize" driver call
     * so there is no corresponding free(r).  Coverity is correct that
     * it is never freed but this is not a problem.                   
     */                                                               
    r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
   1dee8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    r->trace = false;                                                 
   1deec:	e5c0700e 	strb	r7, [r0, #14]                                <== NOT EXECUTED
   1def0:	e1a06007 	mov	r6, r7                                        <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
   1def4:	e28d9018 	add	r9, sp, #24                                   <== NOT EXECUTED
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
   1def8:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
     * so there is no corresponding free(r).  Coverity is correct that
     * it is never freed but this is not a problem.                   
     */                                                               
    r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
    r->trace = false;                                                 
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
   1defc:	ea00002f 	b	1dfc0 <ramdisk_initialize+0x104>                <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
   1df00:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
   1df04:	e58d6028 	str	r6, [sp, #40]	; 0x28                          <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
   1df08:	e58d3024 	str	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
  return temp.device;                                                 
   1df0c:	e28dc024 	add	ip, sp, #36	; 0x24                            <== NOT EXECUTED
   1df10:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
   1df14:	e59f10c4 	ldr	r1, [pc, #196]	; 1dfe0 <ramdisk_initialize+0x124><== NOT EXECUTED
   1df18:	e3a02009 	mov	r2, #9                                        <== NOT EXECUTED
   1df1c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   1df20:	e58db00c 	str	fp, [sp, #12]                                 <== NOT EXECUTED
   1df24:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
   1df28:	eb0088a4 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
        r->block_size = c->block_size;                                
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
   1df2c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
    r->trace = false;                                                 
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
   1df30:	e5dd1020 	ldrb	r1, [sp, #32]                                <== NOT EXECUTED
        r->block_size = c->block_size;                                
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
   1df34:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
        r->block_size = c->block_size;                                
   1df38:	e9150005 	ldmdb	r5, {r0, r2}                                <== NOT EXECUTED
    r->trace = false;                                                 
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
   1df3c:	e0861001 	add	r1, r6, r1                                    <== NOT EXECUTED
                r->initialized = true;                                
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
   1df40:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
    r->trace = false;                                                 
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
   1df44:	e5cd1020 	strb	r1, [sp, #32]                                <== NOT EXECUTED
        r->block_size = c->block_size;                                
   1df48:	e8840005 	stm	r4, {r0, r2}                                  <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
            r->area = c->location;                                    
   1df4c:	15843008 	strne	r3, [r4, #8]                                <== NOT EXECUTED
                r->initialized = true;                                
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
   1df50:	15c4c00d 	strbne	ip, [r4, #13]                              <== NOT EXECUTED
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
        r->block_size = c->block_size;                                
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
   1df54:	1a000006 	bne	1df74 <ramdisk_initialize+0xb8>               <== NOT EXECUTED
        {                                                             
            r->malloced = true;                                       
            r->area = malloc(r->block_size * r->block_num);           
   1df58:	e0000092 	mul	r0, r2, r0                                    <== NOT EXECUTED
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
        r->block_size = c->block_size;                                
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
        {                                                             
            r->malloced = true;                                       
   1df5c:	e5c4800d 	strb	r8, [r4, #13]                                <== NOT EXECUTED
            r->area = malloc(r->block_size * r->block_num);           
   1df60:	ebffa77a 	bl	7d50 <malloc>                                  <== NOT EXECUTED
            if (r->area == NULL) /* No enough memory for this disk */ 
   1df64:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        r->block_size = c->block_size;                                
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
        {                                                             
            r->malloced = true;                                       
            r->area = malloc(r->block_size * r->block_num);           
   1df68:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
            if (r->area == NULL) /* No enough memory for this disk */ 
            {                                                         
                r->initialized = false;                               
   1df6c:	05c4000c 	strbeq	r0, [r4, #12]                              <== NOT EXECUTED
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
        {                                                             
            r->malloced = true;                                       
            r->area = malloc(r->block_size * r->block_num);           
            if (r->area == NULL) /* No enough memory for this disk */ 
   1df70:	0a00000f 	beq	1dfb4 <ramdisk_initialize+0xf8>               <== NOT EXECUTED
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
            r->area = c->location;                                    
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
   1df74:	e59fb068 	ldr	fp, [pc, #104]	; 1dfe4 <ramdisk_initialize+0x128><== NOT EXECUTED
   1df78:	e28d100c 	add	r1, sp, #12                                   <== NOT EXECUTED
   1df7c:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   1df80:	e915000c 	ldmdb	r5, {r2, r3}                                <== NOT EXECUTED
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
   1df84:	e5c4800c 	strb	r8, [r4, #12]                                <== NOT EXECUTED
            r->area = c->location;                                    
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
   1df88:	e58db000 	str	fp, [sp]                                      <== NOT EXECUTED
   1df8c:	e98d0210 	stmib	sp, {r4, r9}                                <== NOT EXECUTED
   1df90:	ebffa1f7 	bl	6774 <rtems_disk_create_phys>                  <== NOT EXECUTED
                                    ramdisk_ioctl, r, name);          
        if (rc != RTEMS_SUCCESSFUL)                                   
   1df94:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1df98:	0a000005 	beq	1dfb4 <ramdisk_initialize+0xf8>               <== NOT EXECUTED
        {                                                             
            if (r->malloced)                                          
   1df9c:	e5d4300d 	ldrb	r3, [r4, #13]                                <== NOT EXECUTED
   1dfa0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            {                                                         
                free(r->area);                                        
   1dfa4:	15940008 	ldrne	r0, [r4, #8]                                <== NOT EXECUTED
   1dfa8:	1bffa5c1 	blne	76b4 <free>                                  <== NOT EXECUTED
            }                                                         
            r->initialized = false;                                   
   1dfac:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1dfb0:	e5c4c00c 	strb	ip, [r4, #12]                                <== NOT EXECUTED
     * so there is no corresponding free(r).  Coverity is correct that
     * it is never freed but this is not a problem.                   
     */                                                               
    r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
    r->trace = false;                                                 
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
   1dfb4:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   1dfb8:	e2844010 	add	r4, r4, #16                                   <== NOT EXECUTED
   1dfbc:	e285500c 	add	r5, r5, #12                                   <== NOT EXECUTED
   1dfc0:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
   1dfc4:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
   1dfc8:	3affffcc 	bcc	1df00 <ramdisk_initialize+0x44>               <== NOT EXECUTED
            }                                                         
            r->initialized = false;                                   
        }                                                             
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
   1dfcc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1dfd0:	e28dd02c 	add	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
   1dfd4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

000099dc <ramdisk_ioctl>: } int ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) { switch (req)
    99dc:	e59f30dc 	ldr	r3, [pc, #220]	; 9ac0 <ramdisk_ioctl+0xe4>    
    99e0:	e1510003 	cmp	r1, r3                                        
    return 0;                                                         
}                                                                     
                                                                      
int                                                                   
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)        
{                                                                     
    99e4:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
    99e8:	e1a04002 	mov	r4, r2                                        
    switch (req)                                                      
    99ec:	1a00002f 	bne	9ab0 <ramdisk_ioctl+0xd4>                     
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
            struct ramdisk *rd = rtems_disk_get_driver_data(dd);      
                                                                      
            switch (r->req)                                           
    99f0:	e5927000 	ldr	r7, [r2]                                      
    switch (req)                                                      
    {                                                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
            struct ramdisk *rd = rtems_disk_get_driver_data(dd);      
    99f4:	e590602c 	ldr	r6, [r0, #44]	; 0x2c                          
                                                                      
            switch (r->req)                                           
    99f8:	e3570000 	cmp	r7, #0                                        
#endif                                                                
                                                                      
static int                                                            
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)           
{                                                                     
    uint8_t *from = rd->area;                                         
    99fc:	05968008 	ldreq	r8, [r6, #8]                                
    9a00:	02825018 	addeq	r5, r2, #24                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
            struct ramdisk *rd = rtems_disk_get_driver_data(dd);      
                                                                      
            switch (r->req)                                           
    9a04:	0a000009 	beq	9a30 <ramdisk_ioctl+0x54>                     
    9a08:	e3570001 	cmp	r7, #1                                        
    9a0c:	1a000022 	bne	9a9c <ramdisk_ioctl+0xc0>                     
    9a10:	ea00000b 	b	9a44 <ramdisk_ioctl+0x68>                       
#if RTEMS_RAMDISK_TRACE                                               
        rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
                              i, sg->block, sg->length, sg->block * rd->block_size,
                              from + (sg->block * rd->block_size));   
#endif                                                                
        memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
    9a14:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    9a18:	e5151010 	ldr	r1, [r5, #-16]                                <== NOT EXECUTED
    9a1c:	e5150008 	ldr	r0, [r5, #-8]                                 <== NOT EXECUTED
    9a20:	e0218193 	mla	r1, r3, r1, r8                                <== NOT EXECUTED
    9a24:	e515200c 	ldr	r2, [r5, #-12]                                <== NOT EXECUTED
    9a28:	eb001f56 	bl	11788 <memcpy>                                 <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE                                               
    rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",    
                          req->bufs[0].block, req->bufnum);           
#endif                                                                
                                                                      
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)           
    9a2c:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
    9a30:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
    9a34:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
    9a38:	e2855010 	add	r5, r5, #16                                   <== NOT EXECUTED
    9a3c:	3afffff4 	bcc	9a14 <ramdisk_ioctl+0x38>                     <== NOT EXECUTED
    9a40:	ea00000e 	b	9a80 <ramdisk_ioctl+0xa4>                       <== NOT EXECUTED
}                                                                     
                                                                      
static int                                                            
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)          
{                                                                     
    uint8_t *to = rd->area;                                           
    9a44:	e5968008 	ldr	r8, [r6, #8]                                  
    9a48:	e2825018 	add	r5, r2, #24                                   
    9a4c:	e3a07000 	mov	r7, #0                                        
    9a50:	ea000006 	b	9a70 <ramdisk_ioctl+0x94>                       
#if RTEMS_RAMDISK_TRACE                                               
        rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
                              i, sg->block, sg->length, sg->block * rd->block_size,
                              to + (sg->block * rd->block_size));     
#endif                                                                
        memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
    9a54:	e5963000 	ldr	r3, [r6]                                      
    9a58:	e5150010 	ldr	r0, [r5, #-16]                                
    9a5c:	e5151008 	ldr	r1, [r5, #-8]                                 
    9a60:	e0208093 	mla	r0, r3, r0, r8                                
    9a64:	e515200c 	ldr	r2, [r5, #-12]                                
    9a68:	eb001f46 	bl	11788 <memcpy>                                 
                                                                      
#if RTEMS_RAMDISK_TRACE                                               
    rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",   
                          req->bufs[0].block, req->bufnum);           
#endif                                                                
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)           
    9a6c:	e2877001 	add	r7, r7, #1                                    
    9a70:	e5943010 	ldr	r3, [r4, #16]                                 
    9a74:	e1570003 	cmp	r7, r3                                        
    9a78:	e2855010 	add	r5, r5, #16                                   
    9a7c:	3afffff4 	bcc	9a54 <ramdisk_ioctl+0x78>                     
                              i, sg->block, sg->length, sg->block * rd->block_size,
                              to + (sg->block * rd->block_size));     
#endif                                                                
        memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
    }                                                                 
    req->status = RTEMS_SUCCESSFUL;                                   
    9a80:	e3a05000 	mov	r5, #0                                        
    9a84:	e584500c 	str	r5, [r4, #12]                                 
    req->req_done(req->done_arg, RTEMS_SUCCESSFUL);                   
    9a88:	e5940008 	ldr	r0, [r4, #8]                                  
    9a8c:	e1a01005 	mov	r1, r5                                        
    9a90:	e1a0e00f 	mov	lr, pc                                        
    9a94:	e594f004 	ldr	pc, [r4, #4]                                  
            {                                                         
                case RTEMS_BLKDEV_REQ_READ:                           
                    return ramdisk_read(rd, r);                       
                                                                      
                case RTEMS_BLKDEV_REQ_WRITE:                          
                    return ramdisk_write(rd, r);                      
    9a98:	ea000006 	b	9ab8 <ramdisk_ioctl+0xdc>                       
                                                                      
                default:                                              
                    errno = EINVAL;                                   
    9a9c:	eb001d2b 	bl	10f50 <__errno>                                <== NOT EXECUTED
    9aa0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    9aa4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    9aa8:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
                    return -1;                                        
    9aac:	ea000001 	b	9ab8 <ramdisk_ioctl+0xdc>                       <== NOT EXECUTED
            break;                                                    
    }                                                                 
                                                                      
    errno = EINVAL;                                                   
    return -1;                                                        
}                                                                     
    9ab0:	e8bd41f0 	pop	{r4, r5, r6, r7, r8, lr}                      
            }                                                         
            break;                                                    
        }                                                             
                                                                      
        default:                                                      
            return rtems_blkdev_ioctl (dd, req, argp);                
    9ab4:	ea000931 	b	bf80 <rtems_blkdev_ioctl>                       
            break;                                                    
    }                                                                 
                                                                      
    errno = EINVAL;                                                   
    return -1;                                                        
}                                                                     
    9ab8:	e1a00005 	mov	r0, r5                                        
    9abc:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

00009b6c <ramdisk_register>: rtems_blkdev_bnum block_count, bool trace, const char *disk, dev_t *dev_ptr ) {
    9b6c:	e92d47ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
    9b70:	e3a0e000 	mov	lr, #0                                        
    9b74:	e28dc010 	add	ip, sp, #16                                   
    9b78:	e52ce004 	str	lr, [ip, #-4]!                                
  rtems_blkdev_bnum block_count,                                      
  bool trace,                                                         
  const char *disk,                                                   
  dev_t *dev_ptr                                                      
)                                                                     
{                                                                     
    9b7c:	e1a04002 	mov	r4, r2                                        
    9b80:	e1a07000 	mov	r7, r0                                        
    9b84:	e1a06001 	mov	r6, r1                                        
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
  ramdisk *rd = NULL;                                                 
  dev_t dev = 0;                                                      
                                                                      
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
    9b88:	e1a0000e 	mov	r0, lr                                        
    9b8c:	e1a0200c 	mov	r2, ip                                        
    9b90:	e59f1084 	ldr	r1, [pc, #132]	; 9c1c <ramdisk_register+0xb0> 
  rtems_blkdev_bnum block_count,                                      
  bool trace,                                                         
  const char *disk,                                                   
  dev_t *dev_ptr                                                      
)                                                                     
{                                                                     
    9b94:	e1a0a003 	mov	sl, r3                                        
    9b98:	e59d9030 	ldr	r9, [sp, #48]	; 0x30                          
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
  ramdisk *rd = NULL;                                                 
  dev_t dev = 0;                                                      
                                                                      
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
    9b9c:	ebfff39d 	bl	6a18 <rtems_io_register_driver>                
  if (sc != RTEMS_SUCCESSFUL) {                                       
    9ba0:	e2508000 	subs	r8, r0, #0                                   
  rtems_blkdev_bnum block_count,                                      
  bool trace,                                                         
  const char *disk,                                                   
  dev_t *dev_ptr                                                      
)                                                                     
{                                                                     
    9ba4:	e20440ff 	and	r4, r4, #255	; 0xff                           
  rtems_device_major_number major = 0;                                
  ramdisk *rd = NULL;                                                 
  dev_t dev = 0;                                                      
                                                                      
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
  if (sc != RTEMS_SUCCESSFUL) {                                       
    9ba8:	1a000007 	bne	9bcc <ramdisk_register+0x60>                  
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  rd = ramdisk_allocate(NULL, block_size, block_count, trace);        
    9bac:	e1a03004 	mov	r3, r4                                        
    9bb0:	e1a01007 	mov	r1, r7                                        
    9bb4:	e1a02006 	mov	r2, r6                                        
    9bb8:	ebffffcb 	bl	9aec <ramdisk_allocate>                        
  if (rd == NULL) {                                                   
    9bbc:	e2505000 	subs	r5, r0, #0                                   
    9bc0:	1a000003 	bne	9bd4 <ramdisk_register+0x68>                  
    rtems_io_unregister_driver(major);                                
    9bc4:	e59d000c 	ldr	r0, [sp, #12]                                 <== NOT EXECUTED
    9bc8:	ebfff3ef 	bl	6b8c <rtems_io_unregister_driver>              <== NOT EXECUTED
    9bcc:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
                                                                      
    return RTEMS_UNSATISFIED;                                         
    9bd0:	ea00000f 	b	9c14 <ramdisk_register+0xa8>                    <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
    9bd4:	e59d400c 	ldr	r4, [sp, #12]                                 
  }                                                                   
                                                                      
  dev = rtems_filesystem_make_dev_t(major, 0);                        
                                                                      
  sc = rtems_disk_create_phys(                                        
    9bd8:	e59fc040 	ldr	ip, [pc, #64]	; 9c20 <ramdisk_register+0xb4>  
    9bdc:	e1a01008 	mov	r1, r8                                        
    9be0:	e1a02007 	mov	r2, r7                                        
    9be4:	e1a03006 	mov	r3, r6                                        
    9be8:	e1a00004 	mov	r0, r4                                        
    9bec:	e58dc000 	str	ip, [sp]                                      
    9bf0:	e98d0420 	stmib	sp, {r5, sl}                                
    9bf4:	ebffe1da 	bl	2364 <rtems_disk_create_phys>                  
    block_count,                                                      
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
    9bf8:	e3500000 	cmp	r0, #0                                        
    rtems_io_unregister_driver(major);                                
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
    9bfc:	05894000 	streq	r4, [r9]                                    
    9c00:	05890004 	streq	r0, [r9, #4]                                
    block_count,                                                      
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
    9c04:	0a000002 	beq	9c14 <ramdisk_register+0xa8>                  
    ramdisk_free(rd);                                                 
    9c08:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    9c0c:	ebffffac 	bl	9ac4 <ramdisk_free>                            <== NOT EXECUTED
    9c10:	eaffffeb 	b	9bc4 <ramdisk_register+0x58>                    <== NOT EXECUTED
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    9c14:	e28dd010 	add	sp, sp, #16                                   
    9c18:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
                                                                      

00018f38 <read>: ) { ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd );
   18f38:	e59f30b0 	ldr	r3, [pc, #176]	; 18ff0 <read+0xb8>            
   18f3c:	e5933000 	ldr	r3, [r3]                                      
   18f40:	e1500003 	cmp	r0, r3                                        
ssize_t read(                                                         
  int         fd,                                                     
  void       *buffer,                                                 
  size_t      count                                                   
)                                                                     
{                                                                     
   18f44:	e92d4070 	push	{r4, r5, r6, lr}                             
   18f48:	e1a05001 	mov	r5, r1                                        
  ssize_t      rc;                                                    
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
   18f4c:	2a00000f 	bcs	18f90 <read+0x58>                             
  iop = rtems_libio_iop( fd );                                        
   18f50:	e59f309c 	ldr	r3, [pc, #156]	; 18ff4 <read+0xbc>            
   18f54:	e5934000 	ldr	r4, [r3]                                      
   18f58:	e0844300 	add	r4, r4, r0, lsl #6                            
  rtems_libio_check_is_open( iop );                                   
   18f5c:	e5943014 	ldr	r3, [r4, #20]                                 
   18f60:	e3130c01 	tst	r3, #256	; 0x100                              
   18f64:	0a000009 	beq	18f90 <read+0x58>                             
  rtems_libio_check_buffer( buffer );                                 
   18f68:	e3510000 	cmp	r1, #0                                        
   18f6c:	1a000002 	bne	18f7c <read+0x44>                             
   18f70:	ebffd113 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   18f74:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   18f78:	ea00000d 	b	18fb4 <read+0x7c>                               <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
   18f7c:	e3520000 	cmp	r2, #0                                        
   18f80:	01a00002 	moveq	r0, r2                                      
   18f84:	08bd8070 	popeq	{r4, r5, r6, pc}                            
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
   18f88:	e3130002 	tst	r3, #2                                        
   18f8c:	1a000002 	bne	18f9c <read+0x64>                             
   18f90:	ebffd10b 	bl	d3c4 <__errno>                                 
   18f94:	e3a03009 	mov	r3, #9                                        
   18f98:	ea000005 	b	18fb4 <read+0x7c>                               
                                                                      
  /*                                                                  
   *  Now process the read().                                         
   */                                                                 
                                                                      
  if ( !iop->handlers->read_h )                                       
   18f9c:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   18fa0:	e5933008 	ldr	r3, [r3, #8]                                  
   18fa4:	e3530000 	cmp	r3, #0                                        
   18fa8:	1a000004 	bne	18fc0 <read+0x88>                             
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   18fac:	ebffd104 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   18fb0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   18fb4:	e5803000 	str	r3, [r0]                                      
   18fb8:	e3e00000 	mvn	r0, #0                                        
   18fbc:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      
  rc = (*iop->handlers->read_h)( iop, buffer, count );                
   18fc0:	e1a00004 	mov	r0, r4                                        
   18fc4:	e1a0e00f 	mov	lr, pc                                        
   18fc8:	e12fff13 	bx	r3                                             
                                                                      
  if ( rc > 0 )                                                       
   18fcc:	e3500000 	cmp	r0, #0                                        
   18fd0:	d8bd8070 	pople	{r4, r5, r6, pc}                            
    iop->offset += rc;                                                
   18fd4:	e284600c 	add	r6, r4, #12                                   
   18fd8:	e8960060 	ldm	r6, {r5, r6}                                  
   18fdc:	e0952000 	adds	r2, r5, r0                                   
   18fe0:	e0a63fc0 	adc	r3, r6, r0, asr #31                           
   18fe4:	e584200c 	str	r2, [r4, #12]                                 
   18fe8:	e5843010 	str	r3, [r4, #16]                                 
                                                                      
  return rc;                                                          
}                                                                     
   18fec:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

0002670c <readlink>: ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) {
   2670c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if (!buf)                                                           
   26710:	e2516000 	subs	r6, r1, #0                                   
ssize_t readlink(                                                     
  const char *pathname,                                               
  char       *buf,                                                    
  size_t      bufsize                                                 
)                                                                     
{                                                                     
   26714:	e24dd018 	sub	sp, sp, #24                                   
   26718:	e1a05002 	mov	r5, r2                                        
   2671c:	e1a07000 	mov	r7, r0                                        
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if (!buf)                                                           
   26720:	1a000002 	bne	26730 <readlink+0x24>                         
    rtems_set_errno_and_return_minus_one( EFAULT );                   
   26724:	eb0059f5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   26728:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
   2672c:	ea000028 	b	267d4 <readlink+0xc8>                           <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
   26730:	eb0074ef 	bl	43af4 <strlen>                                 
   26734:	e28d4004 	add	r4, sp, #4                                    
   26738:	e3a0c000 	mov	ip, #0                                        
   2673c:	e1a01000 	mov	r1, r0                                        
   26740:	e1a0200c 	mov	r2, ip                                        
   26744:	e1a00007 	mov	r0, r7                                        
   26748:	e1a03004 	mov	r3, r4                                        
   2674c:	e58dc000 	str	ip, [sp]                                      
   26750:	ebff83b9 	bl	763c <rtems_filesystem_evaluate_path>          
                                           0, &loc, false );          
  if ( result != 0 )                                                  
   26754:	e3500000 	cmp	r0, #0                                        
   26758:	1a00001e 	bne	267d8 <readlink+0xcc>                         
     return -1;                                                       
                                                                      
  if ( !loc.ops->node_type_h ){                                       
   2675c:	e59d2010 	ldr	r2, [sp, #16]                                 
   26760:	e5923010 	ldr	r3, [r2, #16]                                 
   26764:	e3530000 	cmp	r3, #0                                        
   26768:	0a000012 	beq	267b8 <readlink+0xac>                         
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
   2676c:	e1a00004 	mov	r0, r4                                        
   26770:	e1a0e00f 	mov	lr, pc                                        
   26774:	e12fff13 	bx	r3                                             
   26778:	e3500004 	cmp	r0, #4                                        
   2677c:	e59d2010 	ldr	r2, [sp, #16]                                 
   26780:	0a000009 	beq	267ac <readlink+0xa0>                         
    rtems_filesystem_freenode( &loc );                                
   26784:	e3520000 	cmp	r2, #0                                        
   26788:	0a000004 	beq	267a0 <readlink+0x94>                         
   2678c:	e592301c 	ldr	r3, [r2, #28]                                 
   26790:	e3530000 	cmp	r3, #0                                        
   26794:	11a00004 	movne	r0, r4                                      
   26798:	11a0e00f 	movne	lr, pc                                      
   2679c:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( EINVAL );                   
   267a0:	eb0059d6 	bl	3cf00 <__errno>                                
   267a4:	e3a03016 	mov	r3, #22                                       
   267a8:	ea000009 	b	267d4 <readlink+0xc8>                           
  }                                                                   
                                                                      
  if ( !loc.ops->readlink_h ){                                        
   267ac:	e592303c 	ldr	r3, [r2, #60]	; 0x3c                          
   267b0:	e3530000 	cmp	r3, #0                                        
   267b4:	1a000009 	bne	267e0 <readlink+0xd4>                         
    rtems_filesystem_freenode( &loc );                                
   267b8:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
   267bc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   267c0:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   267c4:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   267c8:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   267cc:	eb0059cb 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   267d0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   267d4:	e5803000 	str	r3, [r0]                                      
   267d8:	e3e05000 	mvn	r5, #0                                        
   267dc:	ea00000d 	b	26818 <readlink+0x10c>                          
  }                                                                   
                                                                      
  result =  (*loc.ops->readlink_h)( &loc, buf, bufsize );             
   267e0:	e1a02005 	mov	r2, r5                                        
   267e4:	e1a01006 	mov	r1, r6                                        
   267e8:	e1a00004 	mov	r0, r4                                        
   267ec:	e1a0e00f 	mov	lr, pc                                        
   267f0:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   267f4:	e59d3010 	ldr	r3, [sp, #16]                                 
   267f8:	e3530000 	cmp	r3, #0                                        
  if ( !loc.ops->readlink_h ){                                        
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result =  (*loc.ops->readlink_h)( &loc, buf, bufsize );             
   267fc:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26800:	0a000004 	beq	26818 <readlink+0x10c>                        
   26804:	e593301c 	ldr	r3, [r3, #28]                                 
   26808:	e3530000 	cmp	r3, #0                                        
   2680c:	11a00004 	movne	r0, r4                                      
   26810:	11a0e00f 	movne	lr, pc                                      
   26814:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
   26818:	e1a00005 	mov	r0, r5                                        
   2681c:	e28dd018 	add	sp, sp, #24                                   
   26820:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

000039dc <readv>: int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd );
    39dc:	e59f3144 	ldr	r3, [pc, #324]	; 3b28 <readv+0x14c>           
    39e0:	e5933000 	ldr	r3, [r3]                                      
    39e4:	e1500003 	cmp	r0, r3                                        
ssize_t readv(                                                        
  int                 fd,                                             
  const struct iovec *iov,                                            
  int                 iovcnt                                          
)                                                                     
{                                                                     
    39e8:	e92d49f0 	push	{r4, r5, r6, r7, r8, fp, lr}                 
    39ec:	e1a08002 	mov	r8, r2                                        
  int            v;                                                   
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
    39f0:	2a000007 	bcs	3a14 <readv+0x38>                             
  iop = rtems_libio_iop( fd );                                        
    39f4:	e59f3130 	ldr	r3, [pc, #304]	; 3b2c <readv+0x150>           
    39f8:	e5936000 	ldr	r6, [r3]                                      
    39fc:	e0866300 	add	r6, r6, r0, lsl #6                            
  rtems_libio_check_is_open( iop );                                   
    3a00:	e5963014 	ldr	r3, [r6, #20]                                 
    3a04:	e3130c01 	tst	r3, #256	; 0x100                              
    3a08:	0a000001 	beq	3a14 <readv+0x38>                             
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
    3a0c:	e3130002 	tst	r3, #2                                        
    3a10:	1a000002 	bne	3a20 <readv+0x44>                             
    3a14:	eb002a90 	bl	e45c <__errno>                                 <== NOT EXECUTED
    3a18:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
    3a1c:	ea00001b 	b	3a90 <readv+0xb4>                               <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
    3a20:	e3510000 	cmp	r1, #0                                        
    3a24:	0a000017 	beq	3a88 <readv+0xac>                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
    3a28:	e3520000 	cmp	r2, #0                                        
    3a2c:	da000015 	ble	3a88 <readv+0xac>                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
    3a30:	e3520b01 	cmp	r2, #1024	; 0x400                             
    3a34:	ca000013 	bgt	3a88 <readv+0xac>                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !iop->handlers->read_h )                                       
    3a38:	e596303c 	ldr	r3, [r6, #60]	; 0x3c                          
    3a3c:	e5933008 	ldr	r3, [r3, #8]                                  
    3a40:	e3530000 	cmp	r3, #0                                        
    3a44:	1a000002 	bne	3a54 <readv+0x78>                             
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    3a48:	eb002a83 	bl	e45c <__errno>                                 <== NOT EXECUTED
    3a4c:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    3a50:	ea00000e 	b	3a90 <readv+0xb4>                               <== NOT EXECUTED
    3a54:	e3a03000 	mov	r3, #0                                        
    3a58:	e1a05001 	mov	r5, r1                                        
    3a5c:	e1a02001 	mov	r2, r1                                        
    3a60:	e3a07001 	mov	r7, #1                                        
    3a64:	e1a01003 	mov	r1, r3                                        
                                                                      
  all_zeros = true;                                                   
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    ssize_t old;                                                      
                                                                      
    if ( !iov[v].iov_base )                                           
    3a68:	e5920000 	ldr	r0, [r2]                                      
    3a6c:	e3500000 	cmp	r0, #0                                        
   *  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++ ) {                           
    3a70:	e2833001 	add	r3, r3, #1                                    
    ssize_t old;                                                      
                                                                      
    if ( !iov[v].iov_base )                                           
    3a74:	0a000003 	beq	3a88 <readv+0xac>                             
    if ( iov[v].iov_len < 0 )                                         
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    3a78:	e592c004 	ldr	ip, [r2, #4]                                  
    3a7c:	e081000c 	add	r0, r1, ip                                    
    if ( total < old )                                                
    3a80:	e1500001 	cmp	r0, r1                                        
    3a84:	aa000003 	bge	3a98 <readv+0xbc>                             
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    3a88:	eb002a73 	bl	e45c <__errno>                                 
    3a8c:	e3a03016 	mov	r3, #22                                       
    3a90:	e5803000 	str	r3, [r0]                                      
    3a94:	ea000011 	b	3ae0 <readv+0x104>                              
                                                                      
    if ( iov[v].iov_len )                                             
    3a98:	e35c0000 	cmp	ip, #0                                        
    3a9c:	13a07000 	movne	r7, #0                                      
   *  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++ ) {                           
    3aa0:	e1530008 	cmp	r3, r8                                        
    3aa4:	e2822008 	add	r2, r2, #8                                    
    3aa8:	b1a01000 	movlt	r1, r0                                      
    3aac:	baffffed 	blt	3a68 <readv+0x8c>                             
  /*                                                                  
   *  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 ) {                                          
    3ab0:	e3570000 	cmp	r7, #0                                        
    3ab4:	13a04000 	movne	r4, #0                                      
    3ab8:	1a000018 	bne	3b20 <readv+0x144>                            
    3abc:	e1a04007 	mov	r4, r7                                        
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
    3ac0:	e8950006 	ldm	r5, {r1, r2}                                  
    3ac4:	e596303c 	ldr	r3, [r6, #60]	; 0x3c                          
    3ac8:	e1a00006 	mov	r0, r6                                        
    3acc:	e1a0e00f 	mov	lr, pc                                        
    3ad0:	e593f008 	ldr	pc, [r3, #8]                                  
                                                                      
    if ( bytes < 0 )                                                  
    3ad4:	e3500000 	cmp	r0, #0                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    3ad8:	e2877001 	add	r7, r7, #1                                    
    bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
                                                                      
    if ( bytes < 0 )                                                  
    3adc:	aa000001 	bge	3ae8 <readv+0x10c>                            
    3ae0:	e3e04000 	mvn	r4, #0                                        
    3ae4:	ea00000d 	b	3b20 <readv+0x144>                              
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
    3ae8:	0a000006 	beq	3b08 <readv+0x12c>                            
      iop->offset += bytes;                                           
    3aec:	e286c00c 	add	ip, r6, #12                                   
    3af0:	e89c1800 	ldm	ip, {fp, ip}                                  
    3af4:	e09b2000 	adds	r2, fp, r0                                   
    3af8:	e0ac3fc0 	adc	r3, ip, r0, asr #31                           
    3afc:	e586200c 	str	r2, [r6, #12]                                 
    3b00:	e5863010 	str	r3, [r6, #16]                                 
      total       += bytes;                                           
    3b04:	e0844000 	add	r4, r4, r0                                    
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
    3b08:	e5953004 	ldr	r3, [r5, #4]                                  
    3b0c:	e1500003 	cmp	r0, r3                                        
    3b10:	1a000002 	bne	3b20 <readv+0x144>                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    3b14:	e1570008 	cmp	r7, r8                                        
    3b18:	e2855008 	add	r5, r5, #8                                    
    3b1c:	baffffe7 	blt	3ac0 <readv+0xe4>                             
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
    3b20:	e1a00004 	mov	r0, r4                                        
    3b24:	e8bd89f0 	pop	{r4, r5, r6, r7, r8, fp, pc}                  
                                                                      

00019050 <realloc>: { uintptr_t old_size; char *new_area; uintptr_t resize; MSBUMP(realloc_calls, 1);
   19050:	e59f310c 	ldr	r3, [pc, #268]	; 19164 <realloc+0x114>        
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
   19054:	e59f210c 	ldr	r2, [pc, #268]	; 19168 <realloc+0x118>        
   19058:	e592c000 	ldr	ip, [r2]                                      
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
  uintptr_t resize;                                                   
                                                                      
  MSBUMP(realloc_calls, 1);                                           
   1905c:	e5932010 	ldr	r2, [r3, #16]                                 
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
   19060:	e35c0003 	cmp	ip, #3                                        
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
  uintptr_t resize;                                                   
                                                                      
  MSBUMP(realloc_calls, 1);                                           
   19064:	e2822001 	add	r2, r2, #1                                    
   19068:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     
   1906c:	e5832010 	str	r2, [r3, #16]                                 
   19070:	e1a04000 	mov	r4, r0                                        
   19074:	e1a05001 	mov	r5, r1                                        
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
   19078:	1a000007 	bne	1909c <realloc+0x4c>                          
    if (_Thread_Dispatch_disable_level > 0)                           
   1907c:	e59f30e8 	ldr	r3, [pc, #232]	; 1916c <realloc+0x11c>        
   19080:	e5933000 	ldr	r3, [r3]                                      
   19084:	e3530000 	cmp	r3, #0                                        
   19088:	1a000032 	bne	19158 <realloc+0x108>                         
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
   1908c:	e59f30dc 	ldr	r3, [pc, #220]	; 19170 <realloc+0x120>        
   19090:	e5933000 	ldr	r3, [r3]                                      
   19094:	e3530000 	cmp	r3, #0                                        
   19098:	1a00002e 	bne	19158 <realloc+0x108>                         
  }                                                                   
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
   1909c:	e3540000 	cmp	r4, #0                                        
   190a0:	1a000003 	bne	190b4 <realloc+0x64>                          
    return malloc( size );                                            
   190a4:	e1a00005 	mov	r0, r5                                        
   190a8:	ebffa454 	bl	2200 <malloc>                                  
   190ac:	e1a04000 	mov	r4, r0                                        
   190b0:	ea000029 	b	1915c <realloc+0x10c>                           
                                                                      
  if ( !size ) {                                                      
   190b4:	e3550000 	cmp	r5, #0                                        
   190b8:	1a000003 	bne	190cc <realloc+0x7c>                          
    free( ptr );                                                      
   190bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   190c0:	ebffa382 	bl	1ed0 <free>                                    <== NOT EXECUTED
   190c4:	e1a04005 	mov	r4, r5                                        <== NOT EXECUTED
    return (void *) 0;                                                
   190c8:	ea000023 	b	1915c <realloc+0x10c>                           <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
   190cc:	e59f60a0 	ldr	r6, [pc, #160]	; 19174 <realloc+0x124>        
   190d0:	e1a01004 	mov	r1, r4                                        
   190d4:	e5960000 	ldr	r0, [r6]                                      
   190d8:	e1a0200d 	mov	r2, sp                                        
   190dc:	eb000055 	bl	19238 <_Protected_heap_Get_block_size>         
   190e0:	e2507000 	subs	r7, r0, #0                                   
   190e4:	1a000004 	bne	190fc <realloc+0xac>                          
    errno = EINVAL;                                                   
   190e8:	ebffd0b5 	bl	d3c4 <__errno>                                 
   190ec:	e3a03016 	mov	r3, #22                                       
   190f0:	e5803000 	str	r3, [r0]                                      
   190f4:	e1a04007 	mov	r4, r7                                        
    return (void *) 0;                                                
   190f8:	ea000017 	b	1915c <realloc+0x10c>                           
  #if defined(RTEMS_MALLOC_BOUNDARY_HELPERS)                          
    if (rtems_malloc_boundary_helpers)                                
      resize += (*rtems_malloc_boundary_helpers->overhead)();         
  #endif                                                              
                                                                      
  if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, resize ) ) {
   190fc:	e5960000 	ldr	r0, [r6]                                      
   19100:	e1a01004 	mov	r1, r4                                        
   19104:	e1a02005 	mov	r2, r5                                        
   19108:	eb00005b 	bl	1927c <_Protected_heap_Resize_block>           
   1910c:	e3500000 	cmp	r0, #0                                        
   19110:	1a000011 	bne	1915c <realloc+0x10c>                         
   *  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 );                                          
   19114:	e1a00005 	mov	r0, r5                                        
   19118:	ebffa438 	bl	2200 <malloc>                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
   1911c:	e59f3040 	ldr	r3, [pc, #64]	; 19164 <realloc+0x114>         
   19120:	e5932004 	ldr	r2, [r3, #4]                                  
                                                                      
  if ( !new_area ) {                                                  
   19124:	e2506000 	subs	r6, r0, #0                                   
   *  and the C Standard.                                             
   */                                                                 
                                                                      
  new_area = malloc( size );                                          
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
   19128:	e2422001 	sub	r2, r2, #1                                    
   1912c:	e5832004 	str	r2, [r3, #4]                                  
                                                                      
  if ( !new_area ) {                                                  
   19130:	0a000008 	beq	19158 <realloc+0x108>                         
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
   19134:	e59d2000 	ldr	r2, [sp]                                      
   19138:	e1a01004 	mov	r1, r4                                        
   1913c:	e1550002 	cmp	r5, r2                                        
   19140:	31a02005 	movcc	r2, r5                                      
   19144:	ebffd2ac 	bl	dbfc <memcpy>                                  
  free( ptr );                                                        
   19148:	e1a00004 	mov	r0, r4                                        
   1914c:	ebffa35f 	bl	1ed0 <free>                                    
   19150:	e1a04006 	mov	r4, r6                                        
                                                                      
  return new_area;                                                    
   19154:	ea000000 	b	1915c <realloc+0x10c>                           
   19158:	e3a04000 	mov	r4, #0                                        
                                                                      
}                                                                     
   1915c:	e1a00004 	mov	r0, r4                                        
   19160:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      
                                                                      

00026824 <rmdir>: #include <rtems/seterr.h> int rmdir( const char *pathname ) {
   26824:	e92d4070 	push	{r4, r5, r6, lr}                             
   26828:	e24dd030 	sub	sp, sp, #48	; 0x30                            
   2682c:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   *  Get the parent node of the node we wish to remove. Find the parent path.
   */                                                                 
                                                                      
  parentpathlen = rtems_filesystem_dirname ( pathname );              
   26830:	ebff833a 	bl	7520 <rtems_filesystem_dirname>                
                                                                      
  if ( parentpathlen == 0 )                                           
   26834:	e2504000 	subs	r4, r0, #0                                   
   26838:	e28d3018 	add	r3, sp, #24                                   
   2683c:	1a000005 	bne	26858 <rmdir+0x34>                            
    rtems_filesystem_get_start_loc( pathname, &i, &parentloc );       
   26840:	e1a02003 	mov	r2, r3                                        
   26844:	e1a00006 	mov	r0, r6                                        
   26848:	e28d102c 	add	r1, sp, #44	; 0x2c                            
   2684c:	ebff89b3 	bl	8f20 <rtems_filesystem_get_start_loc>          
   26850:	e1a05004 	mov	r5, r4                                        
   26854:	ea000008 	b	2687c <rmdir+0x58>                              
  else {                                                              
    result = rtems_filesystem_evaluate_path(pathname, parentpathlen,  
   26858:	e3a0c000 	mov	ip, #0                                        
   2685c:	e1a00006 	mov	r0, r6                                        
   26860:	e1a01004 	mov	r1, r4                                        
   26864:	e3a02002 	mov	r2, #2                                        
   26868:	e58dc000 	str	ip, [sp]                                      
   2686c:	ebff8372 	bl	763c <rtems_filesystem_evaluate_path>          
                                            RTEMS_LIBIO_PERMS_WRITE,  
                                            &parentloc,               
                                            false );                  
    if ( result != 0 )                                                
   26870:	e3500000 	cmp	r0, #0                                        
   26874:	1a000077 	bne	26a58 <rmdir+0x234>                           
   26878:	e3a05001 	mov	r5, #1                                        
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
   2687c:	e28de018 	add	lr, sp, #24                                   
   26880:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
   26884:	e28dc004 	add	ip, sp, #4                                    
   26888:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
   2688c:	e59e3000 	ldr	r3, [lr]                                      
  name = pathname + parentpathlen;                                    
   26890:	e0864004 	add	r4, r6, r4                                    
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
   26894:	e58c3000 	str	r3, [ip]                                      
  name = pathname + parentpathlen;                                    
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
   26898:	e1a00004 	mov	r0, r4                                        
   2689c:	eb007494 	bl	43af4 <strlen>                                 
   268a0:	e1a01000 	mov	r1, r0                                        
   268a4:	e1a00004 	mov	r0, r4                                        
   268a8:	ebff830c 	bl	74e0 <rtems_filesystem_prefix_separators>      
   268ac:	e0846000 	add	r6, r4, r0                                    
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
   268b0:	e1a00006 	mov	r0, r6                                        
   268b4:	eb00748e 	bl	43af4 <strlen>                                 
   268b8:	e28d4004 	add	r4, sp, #4                                    
   268bc:	e3a0c000 	mov	ip, #0                                        
   268c0:	e1a01000 	mov	r1, r0                                        
   268c4:	e1a0200c 	mov	r2, ip                                        
   268c8:	e1a00006 	mov	r0, r6                                        
   268cc:	e1a03004 	mov	r3, r4                                        
   268d0:	e58dc000 	str	ip, [sp]                                      
   268d4:	ebff8320 	bl	755c <rtems_filesystem_evaluate_relative_path> 
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
   268d8:	e3500000 	cmp	r0, #0                                        
   268dc:	0a00000b 	beq	26910 <rmdir+0xec>                            
    if ( free_parentloc )                                             
   268e0:	e3550000 	cmp	r5, #0                                        
   268e4:	0a00005b 	beq	26a58 <rmdir+0x234>                           
      rtems_filesystem_freenode( &parentloc );                        
   268e8:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   268ec:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   268f0:	0a000058 	beq	26a58 <rmdir+0x234>                           <== NOT EXECUTED
   268f4:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   268f8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   268fc:	0a000055 	beq	26a58 <rmdir+0x234>                           <== NOT EXECUTED
   26900:	e28d0018 	add	r0, sp, #24                                   <== NOT EXECUTED
   26904:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   26908:	e12fff13 	bx	r3                                             <== NOT EXECUTED
   2690c:	ea000051 	b	26a58 <rmdir+0x234>                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify you can remove this node as a directory.                  
   */                                                                 
                                                                      
  if ( !loc.ops->node_type_h ){                                       
   26910:	e59d2010 	ldr	r2, [sp, #16]                                 
   26914:	e5923010 	ldr	r3, [r2, #16]                                 
   26918:	e3530000 	cmp	r3, #0                                        
    rtems_filesystem_freenode( &loc );                                
   2691c:	0592301c 	ldreq	r3, [r2, #28]                               
                                                                      
  /*                                                                  
   * Verify you can remove this node as a directory.                  
   */                                                                 
                                                                      
  if ( !loc.ops->node_type_h ){                                       
   26920:	0a000021 	beq	269ac <rmdir+0x188>                           
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){
   26924:	e1a00004 	mov	r0, r4                                        
   26928:	e1a0e00f 	mov	lr, pc                                        
   2692c:	e12fff13 	bx	r3                                             
   26930:	e3500001 	cmp	r0, #1                                        
   26934:	0a000014 	beq	2698c <rmdir+0x168>                           
    rtems_filesystem_freenode( &loc );                                
   26938:	e59d3010 	ldr	r3, [sp, #16]                                 
   2693c:	e3530000 	cmp	r3, #0                                        
   26940:	0a000004 	beq	26958 <rmdir+0x134>                           
   26944:	e593301c 	ldr	r3, [r3, #28]                                 
   26948:	e3530000 	cmp	r3, #0                                        
   2694c:	11a00004 	movne	r0, r4                                      
   26950:	11a0e00f 	movne	lr, pc                                      
   26954:	112fff13 	bxne	r3                                           
    if ( free_parentloc )                                             
   26958:	e3550000 	cmp	r5, #0                                        
   2695c:	0a000007 	beq	26980 <rmdir+0x15c>                           
      rtems_filesystem_freenode( &parentloc );                        
   26960:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
   26964:	e3530000 	cmp	r3, #0                                        
   26968:	0a000004 	beq	26980 <rmdir+0x15c>                           
   2696c:	e593301c 	ldr	r3, [r3, #28]                                 
   26970:	e3530000 	cmp	r3, #0                                        
   26974:	128d0018 	addne	r0, sp, #24                                 
   26978:	11a0e00f 	movne	lr, pc                                      
   2697c:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
   26980:	eb00595e 	bl	3cf00 <__errno>                                
   26984:	e3a03014 	mov	r3, #20                                       
   26988:	ea000017 	b	269ec <rmdir+0x1c8>                             
                                                                      
  /*                                                                  
   * Use the filesystems rmnod to remove the node.                    
   */                                                                 
                                                                      
  if ( !loc.handlers->rmnod_h ){                                      
   2698c:	e59d300c 	ldr	r3, [sp, #12]                                 
   26990:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          
   26994:	e3530000 	cmp	r3, #0                                        
   26998:	1a000015 	bne	269f4 <rmdir+0x1d0>                           
    rtems_filesystem_freenode( &loc );                                
   2699c:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   269a0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   269a4:	0a000004 	beq	269bc <rmdir+0x198>                           <== NOT EXECUTED
   269a8:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   269ac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   269b0:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   269b4:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   269b8:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    if ( free_parentloc )                                             
   269bc:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   269c0:	0a000007 	beq	269e4 <rmdir+0x1c0>                           <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
   269c4:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   269c8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   269cc:	0a000004 	beq	269e4 <rmdir+0x1c0>                           <== NOT EXECUTED
   269d0:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   269d4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   269d8:	128d0018 	addne	r0, sp, #24                                 <== NOT EXECUTED
   269dc:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   269e0:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   269e4:	eb005945 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   269e8:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   269ec:	e5803000 	str	r3, [r0]                                      
   269f0:	ea000018 	b	26a58 <rmdir+0x234>                             
  }                                                                   
                                                                      
  result =  (*loc.handlers->rmnod_h)( &parentloc, &loc );             
   269f4:	e28d0018 	add	r0, sp, #24                                   
   269f8:	e1a01004 	mov	r1, r4                                        
   269fc:	e1a0e00f 	mov	lr, pc                                        
   26a00:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26a04:	e59d3010 	ldr	r3, [sp, #16]                                 
   26a08:	e3530000 	cmp	r3, #0                                        
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result =  (*loc.handlers->rmnod_h)( &parentloc, &loc );             
   26a0c:	e1a06000 	mov	r6, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26a10:	0a000004 	beq	26a28 <rmdir+0x204>                           
   26a14:	e593301c 	ldr	r3, [r3, #28]                                 
   26a18:	e3530000 	cmp	r3, #0                                        
   26a1c:	11a00004 	movne	r0, r4                                      
   26a20:	11a0e00f 	movne	lr, pc                                      
   26a24:	112fff13 	bxne	r3                                           
  if ( free_parentloc )                                               
   26a28:	e3550000 	cmp	r5, #0                                        
   26a2c:	0a00000a 	beq	26a5c <rmdir+0x238>                           
    rtems_filesystem_freenode( &parentloc );                          
   26a30:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
   26a34:	e3530000 	cmp	r3, #0                                        
   26a38:	0a000007 	beq	26a5c <rmdir+0x238>                           
   26a3c:	e593301c 	ldr	r3, [r3, #28]                                 
   26a40:	e3530000 	cmp	r3, #0                                        
   26a44:	0a000004 	beq	26a5c <rmdir+0x238>                           
   26a48:	e28d0018 	add	r0, sp, #24                                   
   26a4c:	e1a0e00f 	mov	lr, pc                                        
   26a50:	e12fff13 	bx	r3                                             
   26a54:	ea000000 	b	26a5c <rmdir+0x238>                             
   26a58:	e3e06000 	mvn	r6, #0                                        
                                                                      
  return result;                                                      
}                                                                     
   26a5c:	e1a00006 	mov	r0, r6                                        
   26a60:	e28dd030 	add	sp, sp, #48	; 0x30                            
   26a64:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00012124 <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; }
   12124:	e59f0000 	ldr	r0, [pc, #0]	; 1212c <rtems_assoc_name_bad+0x8><== NOT EXECUTED
   12128:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0000f2dc <rtems_assoc_name_by_local>: const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
    f2dc:	e92d4010 	push	{r4, lr}                                     
    f2e0:	e1a04001 	mov	r4, r1                                        
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
    f2e4:	eb000006 	bl	f304 <rtems_assoc_ptr_by_local>                
  if (nap)                                                            
    f2e8:	e3500000 	cmp	r0, #0                                        
    f2ec:	0a000001 	beq	f2f8 <rtems_assoc_name_by_local+0x1c>         
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
}                                                                     
    f2f0:	e5900000 	ldr	r0, [r0]                                      
    f2f4:	e8bd8010 	pop	{r4, pc}                                      
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
    f2f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
    f2fc:	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);                           
    f300:	ea000b87 	b	12124 <rtems_assoc_name_bad>                    <== NOT EXECUTED
                                                                      

0000d33c <rtems_assoc_remote_by_local>: uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
    d33c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
    d340:	eb000002 	bl	d350 <rtems_assoc_ptr_by_local>                <== NOT EXECUTED
  if (nap)                                                            
    d344:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return nap->remote_value;                                         
    d348:	15900008 	ldrne	r0, [r0, #8]                                <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
    d34c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00009fec <rtems_bdbuf_add_to_modified_list_after_access>: } } static void rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd) {
    9fec:	e92d4030 	push	{r4, r5, lr}                                 
  if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)  
    9ff0:	e59f50ac 	ldr	r5, [pc, #172]	; a0a4 <rtems_bdbuf_add_to_modified_list_after_access+0xb8>
    9ff4:	e5d53030 	ldrb	r3, [r5, #48]	; 0x30                         
    9ff8:	e3530000 	cmp	r3, #0                                        
  }                                                                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{                                                                     
    9ffc:	e1a04000 	mov	r4, r0                                        
  if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)  
    a000:	0a00000d 	beq	a03c <rtems_bdbuf_add_to_modified_list_after_access+0x50>
    a004:	e2853038 	add	r3, r5, #56	; 0x38                            <== NOT EXECUTED
    a008:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
    a00c:	e5901014 	ldr	r1, [r0, #20]                                 <== NOT EXECUTED
    a010:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    a014:	1a000008 	bne	a03c <rtems_bdbuf_add_to_modified_list_after_access+0x50><== NOT EXECUTED
    a018:	e5901018 	ldr	r1, [r0, #24]                                 <== NOT EXECUTED
    a01c:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
    a020:	1a000005 	bne	a03c <rtems_bdbuf_add_to_modified_list_after_access+0x50><== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
    a024:	ebffff8d 	bl	9e60 <rtems_bdbuf_unlock_cache>                <== NOT EXECUTED
 * Lock the cache's sync. A single task can nest calls.               
 */                                                                   
static void                                                           
rtems_bdbuf_lock_sync (void)                                          
{                                                                     
  rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
    a028:	e595002c 	ldr	r0, [r5, #44]	; 0x2c                          <== NOT EXECUTED
    a02c:	e59f1074 	ldr	r1, [pc, #116]	; a0a8 <rtems_bdbuf_add_to_modified_list_after_access+0xbc><== NOT EXECUTED
    a030:	ebffff08 	bl	9c58 <rtems_bdbuf_lock>                        <== NOT EXECUTED
    /*                                                                
     * Wait for the sync lock.                                        
     */                                                               
    rtems_bdbuf_lock_sync ();                                         
                                                                      
    rtems_bdbuf_unlock_sync ();                                       
    a034:	ebffff93 	bl	9e88 <rtems_bdbuf_unlock_sync>                 <== NOT EXECUTED
    rtems_bdbuf_lock_cache ();                                        
    a038:	ebffff0f 	bl	9c7c <rtems_bdbuf_lock_cache>                  <== NOT EXECUTED
   * nothing being written? We have tended to think we should hold changes for
   * only a specific period of time even if still changing and get onto disk
   * and letting the file system try and recover this position if it can.
   */                                                                 
  if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED                    
        || bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)               
    a03c:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
   * difficult question. Is a snapshot of a block that is changing better than
   * nothing being written? We have tended to think we should hold changes for
   * only a specific period of time even if still changing and get onto disk
   * and letting the file system try and recover this position if it can.
   */                                                                 
  if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED                    
    a040:	e3530003 	cmp	r3, #3                                        
    a044:	0a000002 	beq	a054 <rtems_bdbuf_add_to_modified_list_after_access+0x68>
        || bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)               
    a048:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
   * difficult question. Is a snapshot of a block that is changing better than
   * nothing being written? We have tended to think we should hold changes for
   * only a specific period of time even if still changing and get onto disk
   * and letting the file system try and recover this position if it can.
   */                                                                 
  if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED                    
    a04c:	e3530005 	cmp	r3, #5                                        
    a050:	1a000002 	bne	a060 <rtems_bdbuf_add_to_modified_list_after_access+0x74>
        || bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)               
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
    a054:	e59f3050 	ldr	r3, [pc, #80]	; a0ac <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
    a058:	e5933010 	ldr	r3, [r3, #16]                                 
    a05c:	e5843030 	str	r3, [r4, #48]	; 0x30                          
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
    a060:	e59f503c 	ldr	r5, [pc, #60]	; a0a4 <rtems_bdbuf_add_to_modified_list_after_access+0xb8>
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    a064:	e3a03007 	mov	r3, #7                                        
    a068:	e5843024 	str	r3, [r4, #36]	; 0x24                          
    a06c:	e2850050 	add	r0, r5, #80	; 0x50                            
    a070:	e1a01004 	mov	r1, r4                                        
    a074:	ebfff351 	bl	6dc0 <_Chain_Append>                           
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
                                                                      
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);             
  rtems_chain_append (&bdbuf_cache.modified, &bd->link);              
                                                                      
  if (bd->waiters)                                                    
    a078:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
    a07c:	e3530000 	cmp	r3, #0                                        
    a080:	0a000002 	beq	a090 <rtems_bdbuf_add_to_modified_list_after_access+0xa4>
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
    a084:	e2850068 	add	r0, r5, #104	; 0x68                           
  else if (rtems_bdbuf_has_buffer_waiters ())                         
    rtems_bdbuf_wake_swapper ();                                      
}                                                                     
    a088:	e8bd4030 	pop	{r4, r5, lr}                                  
                                                                      
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);             
  rtems_chain_append (&bdbuf_cache.modified, &bd->link);              
                                                                      
  if (bd->waiters)                                                    
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
    a08c:	eaffff00 	b	9c94 <rtems_bdbuf_wake>                         
}                                                                     
                                                                      
static bool                                                           
rtems_bdbuf_has_buffer_waiters (void)                                 
{                                                                     
  return bdbuf_cache.buffer_waiters.count;                            
    a090:	e5953078 	ldr	r3, [r5, #120]	; 0x78                         
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);             
  rtems_chain_append (&bdbuf_cache.modified, &bd->link);              
                                                                      
  if (bd->waiters)                                                    
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else if (rtems_bdbuf_has_buffer_waiters ())                         
    a094:	e3530000 	cmp	r3, #0                                        
    a098:	08bd8030 	popeq	{r4, r5, pc}                                
    rtems_bdbuf_wake_swapper ();                                      
}                                                                     
    a09c:	e8bd4030 	pop	{r4, r5, lr}                                  
  rtems_chain_append (&bdbuf_cache.modified, &bd->link);              
                                                                      
  if (bd->waiters)                                                    
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else if (rtems_bdbuf_has_buffer_waiters ())                         
    rtems_bdbuf_wake_swapper ();                                      
    a0a0:	eaffffc6 	b	9fc0 <rtems_bdbuf_wake_swapper>                 
                                                                      

0000a1f4 <rtems_bdbuf_anonymous_wait>: rtems_mode prev_mode; /* * Indicate we are waiting. */ ++waiters->count;
    a1f4:	e5903000 	ldr	r3, [r0]                                      
    a1f8:	e2833001 	add	r3, r3, #1                                    
 * The function assumes the cache is locked on entry and it will be locked on
 * exit.                                                              
 */                                                                   
static void                                                           
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)             
{                                                                     
    a1fc:	e92d4030 	push	{r4, r5, lr}                                 
  rtems_mode        prev_mode;                                        
                                                                      
  /*                                                                  
   * Indicate we are waiting.                                         
   */                                                                 
  ++waiters->count;                                                   
    a200:	e5803000 	str	r3, [r0]                                      
 * The function assumes the cache is locked on entry and it will be locked on
 * exit.                                                              
 */                                                                   
static void                                                           
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)             
{                                                                     
    a204:	e1a04000 	mov	r4, r0                                        
   * blocking or just hits that window, and before this task has blocked on the
   * semaphore. If the preempting task flushes the queue this task will not see
   * the flush and may block for ever or until another transaction flushes this
   * semaphore.                                                       
   */                                                                 
  prev_mode = rtems_bdbuf_disable_preemption ();                      
    a208:	ebffffdf 	bl	a18c <rtems_bdbuf_disable_preemption>          
    a20c:	e1a05000 	mov	r5, r0                                        
                                                                      
  /*                                                                  
   * Unlock the cache, wait, and lock the cache when we return.       
   */                                                                 
  rtems_bdbuf_unlock_cache ();                                        
    a210:	ebffff12 	bl	9e60 <rtems_bdbuf_unlock_cache>                
                                                                      
  sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
    a214:	e3a01000 	mov	r1, #0                                        
    a218:	e5940004 	ldr	r0, [r4, #4]                                  
    a21c:	e1a02001 	mov	r2, r1                                        
    a220:	ebfff057 	bl	6384 <rtems_semaphore_obtain>                  
                                                                      
  if (sc == RTEMS_TIMEOUT)                                            
    a224:	e3500006 	cmp	r0, #6                                        
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
    a228:	059f002c 	ldreq	r0, [pc, #44]	; a25c <rtems_bdbuf_anonymous_wait+0x68>
   */                                                                 
  rtems_bdbuf_unlock_cache ();                                        
                                                                      
  sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
                                                                      
  if (sc == RTEMS_TIMEOUT)                                            
    a22c:	0a000002 	beq	a23c <rtems_bdbuf_anonymous_wait+0x48>        
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
                                                                      
  if (sc != RTEMS_UNSATISFIED)                                        
    a230:	e350000d 	cmp	r0, #13                                       
    a234:	0a000001 	beq	a240 <rtems_bdbuf_anonymous_wait+0x4c>        
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
    a238:	e59f0020 	ldr	r0, [pc, #32]	; a260 <rtems_bdbuf_anonymous_wait+0x6c><== NOT EXECUTED
    a23c:	ebfff1be 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    a240:	ebfffe8d 	bl	9c7c <rtems_bdbuf_lock_cache>                  
                                                                      
  rtems_bdbuf_restore_preemption (prev_mode);                         
    a244:	e1a00005 	mov	r0, r5                                        
    a248:	ebffffdd 	bl	a1c4 <rtems_bdbuf_restore_preemption>          
                                                                      
  --waiters->count;                                                   
    a24c:	e5943000 	ldr	r3, [r4]                                      
    a250:	e2433001 	sub	r3, r3, #1                                    
    a254:	e5843000 	str	r3, [r4]                                      
}                                                                     
    a258:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

0000bbc0 <rtems_bdbuf_get>: rtems_status_code rtems_bdbuf_get (dev_t dev, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
    bbc0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
    bbc4:	e24dd014 	sub	sp, sp, #20                                   
  rtems_disk_device  *dd = NULL;                                      
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block = 0;                                
  size_t              bds_per_group = 0;                              
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bbc8:	e28de00c 	add	lr, sp, #12                                   
rtems_bdbuf_get (dev_t                dev,                            
                 rtems_blkdev_bnum    block,                          
                 rtems_bdbuf_buffer **bd_ptr)                         
{                                                                     
  rtems_status_code   sc = RTEMS_SUCCESSFUL;                          
  rtems_disk_device  *dd = NULL;                                      
    bbcc:	e3a0c000 	mov	ip, #0                                        
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block = 0;                                
  size_t              bds_per_group = 0;                              
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bbd0:	e58de000 	str	lr, [sp]                                      
                                                                      
rtems_status_code                                                     
rtems_bdbuf_get (dev_t                dev,                            
                 rtems_blkdev_bnum    block,                          
                 rtems_bdbuf_buffer **bd_ptr)                         
{                                                                     
    bbd4:	e1a05003 	mov	r5, r3                                        
  rtems_disk_device  *dd = NULL;                                      
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block = 0;                                
  size_t              bds_per_group = 0;                              
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bbd8:	e28de008 	add	lr, sp, #8                                    
    bbdc:	e28d3010 	add	r3, sp, #16                                   
{                                                                     
  rtems_status_code   sc = RTEMS_SUCCESSFUL;                          
  rtems_disk_device  *dd = NULL;                                      
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block = 0;                                
  size_t              bds_per_group = 0;                              
    bbe0:	e58dc008 	str	ip, [sp, #8]                                  
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bbe4:	e58de004 	str	lr, [sp, #4]                                  
rtems_bdbuf_get (dev_t                dev,                            
                 rtems_blkdev_bnum    block,                          
                 rtems_bdbuf_buffer **bd_ptr)                         
{                                                                     
  rtems_status_code   sc = RTEMS_SUCCESSFUL;                          
  rtems_disk_device  *dd = NULL;                                      
    bbe8:	e58dc010 	str	ip, [sp, #16]                                 
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block = 0;                                
    bbec:	e58dc00c 	str	ip, [sp, #12]                                 
                                                                      
rtems_status_code                                                     
rtems_bdbuf_get (dev_t                dev,                            
                 rtems_blkdev_bnum    block,                          
                 rtems_bdbuf_buffer **bd_ptr)                         
{                                                                     
    bbf0:	e1a06000 	mov	r6, r0                                        
    bbf4:	e1a07001 	mov	r7, r1                                        
  rtems_disk_device  *dd = NULL;                                      
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block = 0;                                
  size_t              bds_per_group = 0;                              
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bbf8:	ebfff8ac 	bl	9eb0 <rtems_bdbuf_obtain_disk>                 
  if (sc != RTEMS_SUCCESSFUL)                                         
    bbfc:	e2504000 	subs	r4, r0, #0                                   
    bc00:	1a00001e 	bne	bc80 <rtems_bdbuf_get+0xc0>                   
    return sc;                                                        
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    bc04:	ebfff81c 	bl	9c7c <rtems_bdbuf_lock_cache>                  
   */                                                                 
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",    
            media_block, block, (unsigned) dev);                      
                                                                      
  bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
    bc08:	e1a00006 	mov	r0, r6                                        
    bc0c:	e59d3008 	ldr	r3, [sp, #8]                                  
    bc10:	e1a01007 	mov	r1, r7                                        
    bc14:	e59d200c 	ldr	r2, [sp, #12]                                 
    bc18:	ebffff56 	bl	b978 <rtems_bdbuf_get_buffer_for_access>       
                                                                      
  switch (bd->state)                                                  
    bc1c:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          
    bc20:	e3530002 	cmp	r3, #2                                        
   */                                                                 
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",    
            media_block, block, (unsigned) dev);                      
                                                                      
  bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
    bc24:	e1a06000 	mov	r6, r0                                        
                                                                      
  switch (bd->state)                                                  
    bc28:	0a000004 	beq	bc40 <rtems_bdbuf_get+0x80>                   
    bc2c:	e3530007 	cmp	r3, #7                                        
    bc30:	0a000006 	beq	bc50 <rtems_bdbuf_get+0x90>                   
    bc34:	e3530001 	cmp	r3, #1                                        
    bc38:	1a00000b 	bne	bc6c <rtems_bdbuf_get+0xac>                   
    bc3c:	ea000001 	b	bc48 <rtems_bdbuf_get+0x88>                     
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    bc40:	e3a03003 	mov	r3, #3                                        
    bc44:	ea000002 	b	bc54 <rtems_bdbuf_get+0x94>                     
    bc48:	e3a03005 	mov	r3, #5                                        
    bc4c:	ea000000 	b	bc54 <rtems_bdbuf_get+0x94>                     
    bc50:	e3a03004 	mov	r3, #4                                        
    bc54:	e5863024 	str	r3, [r6, #36]	; 0x24                          
  {                                                                   
    rtems_bdbuf_show_users ("get", bd);                               
    rtems_bdbuf_show_usage ();                                        
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    bc58:	ebfff880 	bl	9e60 <rtems_bdbuf_unlock_cache>                
                                                                      
  rtems_bdbuf_release_disk (dd);                                      
    bc5c:	e59d0010 	ldr	r0, [sp, #16]                                 
    bc60:	ebfff8cf 	bl	9fa4 <rtems_bdbuf_release_disk>                
                                                                      
  *bd_ptr = bd;                                                       
    bc64:	e5856000 	str	r6, [r5]                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
    bc68:	ea000004 	b	bc80 <rtems_bdbuf_get+0xc0>                     
       * so just gets the block to fill.                              
       */                                                             
      rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);  
      break;                                                          
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_2);
    bc6c:	e5900024 	ldr	r0, [r0, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    bc70:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    bc74:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    bc78:	e380001e 	orr	r0, r0, #30                                   <== NOT EXECUTED
    bc7c:	ebffeb2e 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
  rtems_bdbuf_release_disk (dd);                                      
                                                                      
  *bd_ptr = bd;                                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    bc80:	e1a00004 	mov	r0, r4                                        
    bc84:	e28dd014 	add	sp, sp, #20                                   
    bc88:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

0000b978 <rtems_bdbuf_get_buffer_for_access>: static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_for_access (dev_t dev, rtems_blkdev_bnum block, size_t bds_per_group) {
    b978:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
static rtems_bdbuf_buffer *                                           
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,                    
                        dev_t                dev,                     
                        rtems_blkdev_bnum    block)                   
{                                                                     
  rtems_bdbuf_buffer* p = *root;                                      
    b97c:	e59f4224 	ldr	r4, [pc, #548]	; bba8 <rtems_bdbuf_get_buffer_for_access+0x230>
                                                                      
static rtems_bdbuf_buffer *                                           
rtems_bdbuf_get_buffer_for_access (dev_t             dev,             
                                   rtems_blkdev_bnum block,           
                                   size_t            bds_per_group)   
{                                                                     
    b980:	e1a06000 	mov	r6, r0                                        
    b984:	e1a05001 	mov	r5, r1                                        
    b988:	e1a07002 	mov	r7, r2                                        
    b98c:	e1a08003 	mov	r8, r3                                        
    b990:	e284a054 	add	sl, r4, #84	; 0x54                            
static rtems_bdbuf_buffer *                                           
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,                    
                        dev_t                dev,                     
                        rtems_blkdev_bnum    block)                   
{                                                                     
  rtems_bdbuf_buffer* p = *root;                                      
    b994:	e5949040 	ldr	r9, [r4, #64]	; 0x40                          
    b998:	ea000009 	b	b9c4 <rtems_bdbuf_get_buffer_for_access+0x4c>   
                                                                      
  while ((p != NULL) && ((p->dev != dev) || (p->block != block)))     
  {                                                                   
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    b99c:	e1550003 	cmp	r5, r3                                        
    b9a0:	8a000004 	bhi	b9b8 <rtems_bdbuf_get_buffer_for_access+0x40> 
    b9a4:	1a000005 	bne	b9c0 <rtems_bdbuf_get_buffer_for_access+0x48> 
    b9a8:	e1560002 	cmp	r6, r2                                        
    b9ac:	8a000001 	bhi	b9b8 <rtems_bdbuf_get_buffer_for_access+0x40> 
    b9b0:	ea000002 	b	b9c0 <rtems_bdbuf_get_buffer_for_access+0x48>   
    b9b4:	2a000001 	bcs	b9c0 <rtems_bdbuf_get_buffer_for_access+0x48> 
    {                                                                 
      p = p->avl.right;                                               
    b9b8:	e599900c 	ldr	r9, [r9, #12]                                 
    b9bc:	ea000000 	b	b9c4 <rtems_bdbuf_get_buffer_for_access+0x4c>   
    }                                                                 
    else                                                              
    {                                                                 
      p = p->avl.left;                                                
    b9c0:	e5999008 	ldr	r9, [r9, #8]                                  
                        dev_t                dev,                     
                        rtems_blkdev_bnum    block)                   
{                                                                     
  rtems_bdbuf_buffer* p = *root;                                      
                                                                      
  while ((p != NULL) && ((p->dev != dev) || (p->block != block)))     
    b9c4:	e3590000 	cmp	r9, #0                                        
    b9c8:	0a000009 	beq	b9f4 <rtems_bdbuf_get_buffer_for_access+0x7c> 
    b9cc:	e5992014 	ldr	r2, [r9, #20]                                 
    b9d0:	e1520006 	cmp	r2, r6                                        
    b9d4:	e5993018 	ldr	r3, [r9, #24]                                 
    b9d8:	1affffef 	bne	b99c <rtems_bdbuf_get_buffer_for_access+0x24> 
    b9dc:	e1530005 	cmp	r3, r5                                        
    b9e0:	1affffed 	bne	b99c <rtems_bdbuf_get_buffer_for_access+0x24> 
    b9e4:	e599301c 	ldr	r3, [r9, #28]                                 
    b9e8:	e1530007 	cmp	r3, r7                                        
    b9ec:	1afffff0 	bne	b9b4 <rtems_bdbuf_get_buffer_for_access+0x3c> 
    b9f0:	ea000067 	b	bb94 <rtems_bdbuf_get_buffer_for_access+0x21c>  
        bd = NULL;                                                    
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
    b9f4:	e1a00006 	mov	r0, r6                                        
    b9f8:	e1a01005 	mov	r1, r5                                        
    b9fc:	e1a02007 	mov	r2, r7                                        
    ba00:	e1a03008 	mov	r3, r8                                        
    ba04:	ebfffeef 	bl	b5c8 <rtems_bdbuf_get_buffer_from_lru_list>    
                                                                      
      if (bd == NULL)                                                 
    ba08:	e2509000 	subs	r9, r0, #0                                   
    ba0c:	1a000038 	bne	baf4 <rtems_bdbuf_get_buffer_for_access+0x17c>
    ba10:	ea000031 	b	badc <rtems_bdbuf_get_buffer_for_access+0x164>  
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    ba14:	e3a0b008 	mov	fp, #8                                        
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
    ba18:	e5993024 	ldr	r3, [r9, #36]	; 0x24                          
    ba1c:	e353000a 	cmp	r3, #10                                       
    ba20:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
    ba24:	ea00001d 	b	baa0 <rtems_bdbuf_get_buffer_for_access+0x128>  <== NOT EXECUTED
    ba28:	0000bab4 	.word	0x0000bab4                                  <== NOT EXECUTED
    ba2c:	0000ba74 	.word	0x0000ba74                                  <== NOT EXECUTED
    ba30:	0000ba74 	.word	0x0000ba74                                  <== NOT EXECUTED
    ba34:	0000ba84 	.word	0x0000ba84                                  <== NOT EXECUTED
    ba38:	0000ba84 	.word	0x0000ba84                                  <== NOT EXECUTED
    ba3c:	0000ba84 	.word	0x0000ba84                                  <== NOT EXECUTED
    ba40:	0000ba84 	.word	0x0000ba84                                  <== NOT EXECUTED
    ba44:	0000ba54 	.word	0x0000ba54                                  <== NOT EXECUTED
    ba48:	0000ba90 	.word	0x0000ba90                                  <== NOT EXECUTED
    ba4c:	0000ba90 	.word	0x0000ba90                                  <== NOT EXECUTED
    ba50:	0000ba90 	.word	0x0000ba90                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
    ba54:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    ba58:	e589b024 	str	fp, [r9, #36]	; 0x24                          <== NOT EXECUTED
    ba5c:	ebffece2 	bl	6dec <_Chain_Extract>                          <== 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 );                               
    ba60:	e59f0144 	ldr	r0, [pc, #324]	; bbac <rtems_bdbuf_get_buffer_for_access+0x234><== NOT EXECUTED
    ba64:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
    ba68:	ebffecd4 	bl	6dc0 <_Chain_Append>                           <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd) 
{                                                                     
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);                 
  rtems_chain_extract (&bd->link);                                    
  rtems_chain_append (&bdbuf_cache.sync, &bd->link);                  
  rtems_bdbuf_wake_swapper ();                                        
    ba6c:	ebfff953 	bl	9fc0 <rtems_bdbuf_wake_swapper>                <== NOT EXECUTED
    ba70:	eaffffe8 	b	ba18 <rtems_bdbuf_get_buffer_for_access+0xa0>   <== NOT EXECUTED
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        rtems_bdbuf_request_sync_for_modified_buffer (bd);            
        break;                                                        
      case RTEMS_BDBUF_STATE_CACHED:                                  
      case RTEMS_BDBUF_STATE_EMPTY:                                   
        if (bd->waiters == 0)                                         
    ba74:	e5993028 	ldr	r3, [r9, #40]	; 0x28                          
    ba78:	e3530000 	cmp	r3, #0                                        
    ba7c:	0a00000c 	beq	bab4 <rtems_bdbuf_get_buffer_for_access+0x13c>
    ba80:	ea000018 	b	bae8 <rtems_bdbuf_get_buffer_for_access+0x170>  
        }                                                             
      case RTEMS_BDBUF_STATE_ACCESS_CACHED:                           
      case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                            
      case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                         
      case RTEMS_BDBUF_STATE_ACCESS_PURGED:                           
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
    ba84:	e1a00009 	mov	r0, r9                                        
    ba88:	e59f1120 	ldr	r1, [pc, #288]	; bbb0 <rtems_bdbuf_get_buffer_for_access+0x238>
    ba8c:	ea000001 	b	ba98 <rtems_bdbuf_get_buffer_for_access+0x120>  
        break;                                                        
      case RTEMS_BDBUF_STATE_SYNC:                                    
      case RTEMS_BDBUF_STATE_TRANSFER:                                
      case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                         
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);         
    ba90:	e59f111c 	ldr	r1, [pc, #284]	; bbb4 <rtems_bdbuf_get_buffer_for_access+0x23c><== NOT EXECUTED
    ba94:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
    ba98:	ebfff9f1 	bl	a264 <rtems_bdbuf_wait>                        
    ba9c:	eaffffdd 	b	ba18 <rtems_bdbuf_get_buffer_for_access+0xa0>   
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
    baa0:	e5990024 	ldr	r0, [r9, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    baa4:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    baa8:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    baac:	e3800006 	orr	r0, r0, #6                                    <== NOT EXECUTED
    bab0:	ea000030 	b	bb78 <rtems_bdbuf_get_buffer_for_access+0x200>  <== NOT EXECUTED
    {                                                                 
      if (bd->group->bds_per_group != bds_per_group)                  
      {                                                               
        if (rtems_bdbuf_wait_for_recycle (bd))                        
        {                                                             
          rtems_bdbuf_remove_from_tree_and_lru_list (bd);             
    bab4:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
    bab8:	ebfffbe3 	bl	aa4c <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    babc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    bac0:	e5893024 	str	r3, [r9, #36]	; 0x24                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(                             
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert(_Chain_Head(the_chain), the_node);                    
    bac4:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
    bac8:	e59f00e8 	ldr	r0, [pc, #232]	; bbb8 <rtems_bdbuf_get_buffer_for_access+0x240><== NOT EXECUTED
    bacc:	eb000bd3 	bl	ea20 <_Chain_Insert>                           <== NOT EXECUTED
      {                                                               
        if (rtems_bdbuf_wait_for_recycle (bd))                        
        {                                                             
          rtems_bdbuf_remove_from_tree_and_lru_list (bd);             
          rtems_bdbuf_make_free_and_add_to_lru_list (bd);             
          rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);             
    bad0:	e59f00e4 	ldr	r0, [pc, #228]	; bbbc <rtems_bdbuf_get_buffer_for_access+0x244><== NOT EXECUTED
    bad4:	ebfff86e 	bl	9c94 <rtems_bdbuf_wake>                        <== NOT EXECUTED
    bad8:	eaffffad 	b	b994 <rtems_bdbuf_get_buffer_for_access+0x1c>   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    badc:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          
    bae0:	e153000a 	cmp	r3, sl                                        
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
    rtems_bdbuf_wake_swapper ();                                      
    bae4:	1bfff935 	blne	9fc0 <rtems_bdbuf_wake_swapper>              
                                                                      
  rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);           
    bae8:	e59f00cc 	ldr	r0, [pc, #204]	; bbbc <rtems_bdbuf_get_buffer_for_access+0x244>
    baec:	ebfff9c0 	bl	a1f4 <rtems_bdbuf_anonymous_wait>              
    baf0:	eaffffa7 	b	b994 <rtems_bdbuf_get_buffer_for_access+0x1c>   
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
    baf4:	e5993024 	ldr	r3, [r9, #36]	; 0x24                          
    baf8:	e2433001 	sub	r3, r3, #1                                    
    bafc:	e3530009 	cmp	r3, #9                                        
    bb00:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
    bb04:	ea000017 	b	bb68 <rtems_bdbuf_get_buffer_for_access+0x1f0>  <== NOT EXECUTED
    bb08:	0000bb7c 	.word	0x0000bb7c                                  <== NOT EXECUTED
    bb0c:	0000bb40 	.word	0x0000bb40                                  <== NOT EXECUTED
    bb10:	0000bb4c 	.word	0x0000bb4c                                  <== NOT EXECUTED
    bb14:	0000bb4c 	.word	0x0000bb4c                                  <== NOT EXECUTED
    bb18:	0000bb4c 	.word	0x0000bb4c                                  <== NOT EXECUTED
    bb1c:	0000bb4c 	.word	0x0000bb4c                                  <== NOT EXECUTED
    bb20:	0000bb30 	.word	0x0000bb30                                  <== NOT EXECUTED
    bb24:	0000bb58 	.word	0x0000bb58                                  <== NOT EXECUTED
    bb28:	0000bb58 	.word	0x0000bb58                                  <== NOT EXECUTED
    bb2c:	0000bb58 	.word	0x0000bb58                                  <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
    bb30:	e599302c 	ldr	r3, [r9, #44]	; 0x2c                          
    bb34:	e593200c 	ldr	r2, [r3, #12]                                 
    bb38:	e2422001 	sub	r2, r2, #1                                    
    bb3c:	e583200c 	str	r2, [r3, #12]                                 
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
    bb40:	e1a00009 	mov	r0, r9                                        
    bb44:	ebffeca8 	bl	6dec <_Chain_Extract>                          
    bb48:	ea00000b 	b	bb7c <rtems_bdbuf_get_buffer_for_access+0x204>  
        return;                                                       
      case RTEMS_BDBUF_STATE_ACCESS_CACHED:                           
      case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                            
      case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                         
      case RTEMS_BDBUF_STATE_ACCESS_PURGED:                           
        rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);           
    bb4c:	e1a00009 	mov	r0, r9                                        
    bb50:	e59f1058 	ldr	r1, [pc, #88]	; bbb0 <rtems_bdbuf_get_buffer_for_access+0x238>
    bb54:	ea000001 	b	bb60 <rtems_bdbuf_get_buffer_for_access+0x1e8>  
        break;                                                        
      case RTEMS_BDBUF_STATE_SYNC:                                    
      case RTEMS_BDBUF_STATE_TRANSFER:                                
      case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                         
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);         
    bb58:	e59f1054 	ldr	r1, [pc, #84]	; bbb4 <rtems_bdbuf_get_buffer_for_access+0x23c>
    bb5c:	e1a00009 	mov	r0, r9                                        
    bb60:	ebfff9bf 	bl	a264 <rtems_bdbuf_wait>                        
    bb64:	eaffffe2 	b	baf4 <rtems_bdbuf_get_buffer_for_access+0x17c>  
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
    bb68:	e5990024 	ldr	r0, [r9, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    bb6c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    bb70:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    bb74:	e3800005 	orr	r0, r0, #5                                    <== NOT EXECUTED
    bb78:	ebffeb6f 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
    bb7c:	e599302c 	ldr	r3, [r9, #44]	; 0x2c                          
    bb80:	e593200c 	ldr	r2, [r3, #12]                                 
    bb84:	e2822001 	add	r2, r2, #1                                    
    bb88:	e583200c 	str	r2, [r3, #12]                                 
                                                                      
  rtems_bdbuf_wait_for_access (bd);                                   
  rtems_bdbuf_group_obtain (bd);                                      
                                                                      
  return bd;                                                          
}                                                                     
    bb8c:	e1a00009 	mov	r0, r9                                        
    bb90:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);      
                                                                      
    if (bd != NULL)                                                   
    {                                                                 
      if (bd->group->bds_per_group != bds_per_group)                  
    bb94:	e599302c 	ldr	r3, [r9, #44]	; 0x2c                          
    bb98:	e5933008 	ldr	r3, [r3, #8]                                  
    bb9c:	e1530008 	cmp	r3, r8                                        
    bba0:	0affffd3 	beq	baf4 <rtems_bdbuf_get_buffer_for_access+0x17c>
    bba4:	eaffff9a 	b	ba14 <rtems_bdbuf_get_buffer_for_access+0x9c>   
                                                                      

0000b5c8 <rtems_bdbuf_get_buffer_from_lru_list>: static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_from_lru_list (dev_t dev, rtems_blkdev_bnum block, size_t bds_per_group) {
    b5c8:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->first;                                            
    b5cc:	e59fc390 	ldr	ip, [pc, #912]	; b964 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
    b5d0:	e24dd088 	sub	sp, sp, #136	; 0x88                           
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    b5d4:	e1a0600c 	mov	r6, ip                                        
    b5d8:	e1a04000 	mov	r4, r0                                        
    b5dc:	e1a05001 	mov	r5, r1                                        
    b5e0:	e58d2004 	str	r2, [sp, #4]                                  
    b5e4:	e1a09003 	mov	r9, r3                                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->first;                                            
    b5e8:	e59c8044 	ldr	r8, [ip, #68]	; 0x44                          
  rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);      
                                                                      
  while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))               
    b5ec:	ea0000d4 	b	b944 <rtems_bdbuf_get_buffer_from_lru_list+0x37c>
              bd->group->bds_per_group, bds_per_group);               
                                                                      
    /*                                                                
     * If nobody waits for this BD, we may recycle it.                
     */                                                               
    if (bd->waiters == 0)                                             
    b5f0:	e5983028 	ldr	r3, [r8, #40]	; 0x28                          
    b5f4:	e3530000 	cmp	r3, #0                                        
    b5f8:	1a0000d0 	bne	b940 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
    {                                                                 
      if (bd->group->bds_per_group == bds_per_group)                  
    b5fc:	e598702c 	ldr	r7, [r8, #44]	; 0x2c                          
    b600:	e5971008 	ldr	r1, [r7, #8]                                  
    b604:	e1510009 	cmp	r1, r9                                        
    b608:	1a000003 	bne	b61c <rtems_bdbuf_get_buffer_from_lru_list+0x54>
      {                                                               
        rtems_bdbuf_remove_from_tree_and_lru_list (bd);               
    b60c:	e1a00008 	mov	r0, r8                                        
    b610:	ebfffd0d 	bl	aa4c <rtems_bdbuf_remove_from_tree_and_lru_list>
    b614:	e1a00008 	mov	r0, r8                                        
    b618:	ea000033 	b	b6ec <rtems_bdbuf_get_buffer_from_lru_list+0x124>
                                                                      
        empty_bd = bd;                                                
      }                                                               
      else if (bd->group->users == 0)                                 
    b61c:	e597a00c 	ldr	sl, [r7, #12]                                 
    b620:	e35a0000 	cmp	sl, #0                                        
    b624:	1a0000c5 	bne	b940 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
                                                                      
  bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group; 
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    b628:	e5960020 	ldr	r0, [r6, #32]                                 
    b62c:	eb003b67 	bl	1a3d0 <__aeabi_uidiv>                          
    b630:	e3a0303c 	mov	r3, #60	; 0x3c                                
    b634:	e0030390 	mul	r3, r0, r3                                    
    b638:	e1a01005 	mov	r1, r5                                        
            group - bdbuf_cache.groups, group->bds_per_group,         
            new_bds_per_group);                                       
                                                                      
  bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group; 
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
    b63c:	e597b010 	ldr	fp, [r7, #16]                                 
    b640:	e1a05004 	mov	r5, r4                                        
    b644:	e1a04003 	mov	r4, r3                                        
    b648:	ea000005 	b	b664 <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_remove_from_tree_and_lru_list (bd);                   
    b64c:	e1a0000b 	mov	r0, fp                                        
    b650:	e58d1000 	str	r1, [sp]                                      
    b654:	ebfffcfc 	bl	aa4c <rtems_bdbuf_remove_from_tree_and_lru_list>
                                                                      
  bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group; 
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    b658:	e59d1000 	ldr	r1, [sp]                                      
    b65c:	e28aa001 	add	sl, sl, #1                                    
    b660:	e08bb004 	add	fp, fp, r4                                    
            group - bdbuf_cache.groups, group->bds_per_group,         
            new_bds_per_group);                                       
                                                                      
  bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group; 
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
    b664:	e5972008 	ldr	r2, [r7, #8]                                  
    b668:	e15a0002 	cmp	sl, r2                                        
    b66c:	3afffff6 	bcc	b64c <rtems_bdbuf_get_buffer_from_lru_list+0x84>
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_remove_from_tree_and_lru_list (bd);                   
                                                                      
  group->bds_per_group = new_bds_per_group;                           
    b670:	e5879008 	str	r9, [r7, #8]                                  
    b674:	e1a04005 	mov	r4, r5                                        
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
                                                                      
  for (b = 1, bd = group->bdbuf + bufs_per_bd;                        
    b678:	e5960020 	ldr	r0, [r6, #32]                                 
    b67c:	e1a05001 	mov	r5, r1                                        
    b680:	e1a01009 	mov	r1, r9                                        
    b684:	eb003b51 	bl	1a3d0 <__aeabi_uidiv>                          
    b688:	e3a0303c 	mov	r3, #60	; 0x3c                                
    b68c:	e0030390 	mul	r3, r0, r3                                    
    b690:	e597b010 	ldr	fp, [r7, #16]                                 
    b694:	e1a0c008 	mov	ip, r8                                        
    b698:	e08bb003 	add	fp, fp, r3                                    
    b69c:	e3a0a001 	mov	sl, #1                                        
    b6a0:	e1a08003 	mov	r8, r3                                        
    b6a4:	ea000008 	b	b6cc <rtems_bdbuf_get_buffer_from_lru_list+0x104>
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    b6a8:	e3a01000 	mov	r1, #0                                        
    b6ac:	e58b1024 	str	r1, [fp, #36]	; 0x24                          
RTEMS_INLINE_ROUTINE void _Chain_Prepend(                             
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert(_Chain_Head(the_chain), the_node);                    
    b6b0:	e59f02b0 	ldr	r0, [pc, #688]	; b968 <rtems_bdbuf_get_buffer_from_lru_list+0x3a0>
    b6b4:	e1a0100b 	mov	r1, fp                                        
    b6b8:	e58dc000 	str	ip, [sp]                                      
    b6bc:	eb000cd7 	bl	ea20 <_Chain_Insert>                           
  group->bds_per_group = new_bds_per_group;                           
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
                                                                      
  for (b = 1, bd = group->bdbuf + bufs_per_bd;                        
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    b6c0:	e59dc000 	ldr	ip, [sp]                                      
    b6c4:	e28aa001 	add	sl, sl, #1                                    
    b6c8:	e08bb008 	add	fp, fp, r8                                    
    rtems_bdbuf_remove_from_tree_and_lru_list (bd);                   
                                                                      
  group->bds_per_group = new_bds_per_group;                           
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
                                                                      
  for (b = 1, bd = group->bdbuf + bufs_per_bd;                        
    b6cc:	e5972008 	ldr	r2, [r7, #8]                                  
    b6d0:	e15a0002 	cmp	sl, r2                                        
    b6d4:	3afffff3 	bcc	b6a8 <rtems_bdbuf_get_buffer_from_lru_list+0xe0>
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_make_free_and_add_to_lru_list (bd);                   
                                                                      
  if (b > 1)                                                          
    b6d8:	e35a0001 	cmp	sl, #1                                        
    b6dc:	e1a0800c 	mov	r8, ip                                        
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
    b6e0:	859f0284 	ldrhi	r0, [pc, #644]	; b96c <rtems_bdbuf_get_buffer_from_lru_list+0x3a4>
    b6e4:	8bfff96a 	blhi	9c94 <rtems_bdbuf_wake>                      
                                                                      
  return group->bdbuf;                                                
    b6e8:	e5970010 	ldr	r0, [r7, #16]                                 
      }                                                               
      else if (bd->group->users == 0)                                 
        empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
    }                                                                 
                                                                      
    if (empty_bd != NULL)                                             
    b6ec:	e3500000 	cmp	r0, #0                                        
    b6f0:	0a000092 	beq	b940 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
                                dev_t               dev,              
                                rtems_blkdev_bnum   block)            
{                                                                     
  bd->dev       = dev;                                                
  bd->block     = block;                                              
  bd->avl.left  = NULL;                                               
    b6f4:	e3a02000 	mov	r2, #0                                        
    b6f8:	e5802008 	str	r2, [r0, #8]                                  
  bd->avl.right = NULL;                                               
    b6fc:	e580200c 	str	r2, [r0, #12]                                 
                       rtems_bdbuf_buffer*  node)                     
{                                                                     
  dev_t             dev = node->dev;                                  
  rtems_blkdev_bnum block = node->block;                              
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
    b700:	e59f125c 	ldr	r1, [pc, #604]	; b964 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
    b704:	e5913040 	ldr	r3, [r1, #64]	; 0x40                          
{                                                                     
  bd->dev       = dev;                                                
  bd->block     = block;                                              
  bd->avl.left  = NULL;                                               
  bd->avl.right = NULL;                                               
  bd->waiters   = 0;                                                  
    b708:	e5802028 	str	r2, [r0, #40]	; 0x28                          
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
    b70c:	e1530002 	cmp	r3, r2                                        
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,               
                                dev_t               dev,              
                                rtems_blkdev_bnum   block)            
{                                                                     
  bd->dev       = dev;                                                
  bd->block     = block;                                              
    b710:	e59d2004 	ldr	r2, [sp, #4]                                  
static void                                                           
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,               
                                dev_t               dev,              
                                rtems_blkdev_bnum   block)            
{                                                                     
  bd->dev       = dev;                                                
    b714:	e5804014 	str	r4, [r0, #20]                                 
    b718:	e5805018 	str	r5, [r0, #24]                                 
  bd->block     = block;                                              
    b71c:	e580201c 	str	r2, [r0, #28]                                 
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
    b720:	128dc008 	addne	ip, sp, #8                                  
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dev != dev) || (p->block != block))                  
    {                                                                 
      p->avl.cache = -1;                                              
    b724:	13e07000 	mvnne	r7, #0                                      
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    {                                                                 
      p->avl.cache = 1;                                               
    b728:	13a06001 	movne	r6, #1                                      
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
    b72c:	1a000019 	bne	b798 <rtems_bdbuf_get_buffer_from_lru_list+0x1d0>
  {                                                                   
    *root = node;                                                     
    b730:	e5810040 	str	r0, [r1, #64]	; 0x40                          
    node->avl.left = NULL;                                            
    node->avl.right = NULL;                                           
    node->avl.bal = 0;                                                
    b734:	e5c03011 	strb	r3, [r0, #17]                                
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
  {                                                                   
    *root = node;                                                     
    node->avl.left = NULL;                                            
    b738:	e5803008 	str	r3, [r0, #8]                                  
    node->avl.right = NULL;                                           
    b73c:	e580300c 	str	r3, [r0, #12]                                 
    b740:	ea00007b 	b	b934 <rtems_bdbuf_get_buffer_from_lru_list+0x36c>
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    b744:	e1520004 	cmp	r2, r4                                        
    b748:	1a00000c 	bne	b780 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
    b74c:	e1510005 	cmp	r1, r5                                        
    b750:	1a00000a 	bne	b780 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
    b754:	e593201c 	ldr	r2, [r3, #28]                                 
    b758:	e59d1004 	ldr	r1, [sp, #4]                                  
    b75c:	e1520001 	cmp	r2, r1                                        
    b760:	2a000005 	bcs	b77c <rtems_bdbuf_get_buffer_from_lru_list+0x1b4>
    {                                                                 
      p->avl.cache = 1;                                               
      q = p->avl.right;                                               
    b764:	e593200c 	ldr	r2, [r3, #12]                                 
      if (q == NULL)                                                  
    b768:	e3520000 	cmp	r2, #0                                        
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    {                                                                 
      p->avl.cache = 1;                                               
    b76c:	e5c36010 	strb	r6, [r3, #16]                                
      q = p->avl.right;                                               
      if (q == NULL)                                                  
    b770:	1a000007 	bne	b794 <rtems_bdbuf_get_buffer_from_lru_list+0x1cc>
      {                                                               
        q = node;                                                     
        p->avl.right = q = node;                                      
    b774:	e583000c 	str	r0, [r3, #12]                                 
    b778:	ea00000f 	b	b7bc <rtems_bdbuf_get_buffer_from_lru_list+0x1f4>
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dev != dev) || (p->block != block))                  
    b77c:	0a000076 	beq	b95c <rtems_bdbuf_get_buffer_from_lru_list+0x394>
    {                                                                 
      p->avl.cache = -1;                                              
      q = p->avl.left;                                                
    b780:	e5932008 	ldr	r2, [r3, #8]                                  
      if (q == NULL)                                                  
    b784:	e3520000 	cmp	r2, #0                                        
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dev != dev) || (p->block != block))                  
    {                                                                 
      p->avl.cache = -1;                                              
    b788:	e5c37010 	strb	r7, [r3, #16]                                
      q = p->avl.left;                                                
      if (q == NULL)                                                  
      {                                                               
        q = node;                                                     
        p->avl.left = q;                                              
    b78c:	05830008 	streq	r0, [r3, #8]                                
    b790:	0a000009 	beq	b7bc <rtems_bdbuf_get_buffer_from_lru_list+0x1f4>
    b794:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    b798:	e5931018 	ldr	r1, [r3, #24]                                 
    b79c:	e1550001 	cmp	r5, r1                                        
    return 0;                                                         
  }                                                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
    b7a0:	e48c3004 	str	r3, [ip], #4                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    b7a4:	e5932014 	ldr	r2, [r3, #20]                                 
    b7a8:	8affffed 	bhi	b764 <rtems_bdbuf_get_buffer_from_lru_list+0x19c>
    b7ac:	1affffe4 	bne	b744 <rtems_bdbuf_get_buffer_from_lru_list+0x17c>
    b7b0:	e1540002 	cmp	r4, r2                                        
    b7b4:	8affffea 	bhi	b764 <rtems_bdbuf_get_buffer_from_lru_list+0x19c>
    b7b8:	eaffffe1 	b	b744 <rtems_bdbuf_get_buffer_from_lru_list+0x17c>
    }                                                                 
                                                                      
    p = q;                                                            
  }                                                                   
                                                                      
  q->avl.left = q->avl.right = NULL;                                  
    b7bc:	e3a01000 	mov	r1, #0                                        
    b7c0:	e580100c 	str	r1, [r0, #12]                                 
    b7c4:	e5801008 	str	r1, [r0, #8]                                  
  q->avl.bal = 0;                                                     
    b7c8:	e5c01011 	strb	r1, [r0, #17]                                
    b7cc:	e24c4004 	sub	r4, ip, #4                                    
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
            if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
            p = p2;                                                   
          }                                                           
          p->avl.bal = 0;                                             
    b7d0:	e3a05001 	mov	r5, #1                                        
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
    b7d4:	e3e06000 	mvn	r6, #0                                        
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
    b7d8:	e28d7008 	add	r7, sp, #8                                    
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
    b7dc:	e1d3c1d0 	ldrsb	ip, [r3, #16]                               
    b7e0:	e37c0001 	cmn	ip, #1                                        
    b7e4:	e1d321d1 	ldrsb	r2, [r3, #17]                               
    b7e8:	1a00001d 	bne	b864 <rtems_bdbuf_get_buffer_from_lru_list+0x29c>
    {                                                                 
      switch (p->avl.bal)                                             
    b7ec:	e3520000 	cmp	r2, #0                                        
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = -1;                                            
    b7f0:	05c3c011 	strbeq	ip, [r3, #17]                              
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
    {                                                                 
      switch (p->avl.bal)                                             
    b7f4:	0a00003f 	beq	b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
    b7f8:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
    b7fc:	0a00001f 	beq	b880 <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== NOT EXECUTED
    b800:	e3720001 	cmn	r2, #1                                        <== NOT EXECUTED
    b804:	1a00003b 	bne	b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330><== NOT EXECUTED
        case 0:                                                       
          p->avl.bal = -1;                                            
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
    b808:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
          if (p1->avl.bal == -1) /* simple LL-turn */                 
    b80c:	e1d2c1d1 	ldrsb	ip, [r2, #17]                               <== NOT EXECUTED
    b810:	e37c0001 	cmn	ip, #1                                        <== NOT EXECUTED
    b814:	e592c00c 	ldr	ip, [r2, #12]                                 <== NOT EXECUTED
          {                                                           
            p->avl.left = p1->avl.right;                              
            p1->avl.right = p;                                        
            p->avl.bal = 0;                                           
    b818:	05c31011 	strbeq	r1, [r3, #17]                              <== NOT EXECUTED
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
          {                                                           
            p->avl.left = p1->avl.right;                              
    b81c:	0583c008 	streq	ip, [r3, #8]                                <== NOT EXECUTED
            p1->avl.right = p;                                        
    b820:	0582300c 	streq	r3, [r2, #12]                               <== NOT EXECUTED
          p->avl.bal = -1;                                            
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
    b824:	0a000030 	beq	b8ec <rtems_bdbuf_get_buffer_from_lru_list+0x324><== NOT EXECUTED
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
    b828:	e59c8008 	ldr	r8, [ip, #8]                                  <== NOT EXECUTED
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
            p2->avl.right = p;                                        
            if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
    b82c:	e1dca1d1 	ldrsb	sl, [ip, #17]                               <== NOT EXECUTED
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
    b830:	e582800c 	str	r8, [r2, #12]                                 <== NOT EXECUTED
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
            p2->avl.right = p;                                        
            if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
    b834:	e37a0001 	cmn	sl, #1                                        <== NOT EXECUTED
    b838:	05c35011 	strbeq	r5, [r3, #17]                              <== NOT EXECUTED
    b83c:	15c31011 	strbne	r1, [r3, #17]                              <== NOT EXECUTED
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
    b840:	e59c800c 	ldr	r8, [ip, #12]                                 <== NOT EXECUTED
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
    b844:	e58c2008 	str	r2, [ip, #8]                                  <== NOT EXECUTED
            p->avl.left = p2->avl.right;                              
            p2->avl.right = p;                                        
    b848:	e58c300c 	str	r3, [ip, #12]                                 <== NOT EXECUTED
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
    b84c:	e5838008 	str	r8, [r3, #8]                                  <== NOT EXECUTED
            p2->avl.right = p;                                        
            if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
    b850:	e1dc31d1 	ldrsb	r3, [ip, #17]                               <== NOT EXECUTED
    b854:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
    b858:	05c26011 	strbeq	r6, [r2, #17]                              <== NOT EXECUTED
    b85c:	1a000020 	bne	b8e4 <rtems_bdbuf_get_buffer_from_lru_list+0x31c><== NOT EXECUTED
    b860:	ea000020 	b	b8e8 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== NOT EXECUTED
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
    b864:	e3520000 	cmp	r2, #0                                        
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = 1;                                             
    b868:	05c35011 	strbeq	r5, [r3, #17]                              
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
    b86c:	0a000021 	beq	b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
    b870:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
    b874:	0a000004 	beq	b88c <rtems_bdbuf_get_buffer_from_lru_list+0x2c4><== NOT EXECUTED
    b878:	e3720001 	cmn	r2, #1                                        <== NOT EXECUTED
    b87c:	1a00001d 	bne	b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330><== NOT EXECUTED
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
    b880:	e5c31011 	strb	r1, [r3, #17]                                <== NOT EXECUTED
    b884:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    b888:	ea000018 	b	b8f0 <rtems_bdbuf_get_buffer_from_lru_list+0x328><== NOT EXECUTED
        case 0:                                                       
          p->avl.bal = 1;                                             
          break;                                                      
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
    b88c:	e593200c 	ldr	r2, [r3, #12]                                 <== NOT EXECUTED
          if (p1->avl.bal == 1) /* simple RR-turn */                  
    b890:	e1d2c1d1 	ldrsb	ip, [r2, #17]                               <== NOT EXECUTED
    b894:	e35c0001 	cmp	ip, #1                                        <== NOT EXECUTED
    b898:	e592c008 	ldr	ip, [r2, #8]                                  <== NOT EXECUTED
          {                                                           
            p->avl.right = p1->avl.left;                              
            p1->avl.left = p;                                         
            p->avl.bal = 0;                                           
    b89c:	05c31011 	strbeq	r1, [r3, #17]                              <== NOT EXECUTED
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
          if (p1->avl.bal == 1) /* simple RR-turn */                  
          {                                                           
            p->avl.right = p1->avl.left;                              
    b8a0:	0583c00c 	streq	ip, [r3, #12]                               <== NOT EXECUTED
            p1->avl.left = p;                                         
    b8a4:	05823008 	streq	r3, [r2, #8]                                <== NOT EXECUTED
          p->avl.bal = 1;                                             
          break;                                                      
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
          if (p1->avl.bal == 1) /* simple RR-turn */                  
    b8a8:	0a00000f 	beq	b8ec <rtems_bdbuf_get_buffer_from_lru_list+0x324><== NOT EXECUTED
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
    b8ac:	e59c800c 	ldr	r8, [ip, #12]                                 <== NOT EXECUTED
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
    b8b0:	e1dca1d1 	ldrsb	sl, [ip, #17]                               <== NOT EXECUTED
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
    b8b4:	e5828008 	str	r8, [r2, #8]                                  <== NOT EXECUTED
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
    b8b8:	e35a0001 	cmp	sl, #1                                        <== NOT EXECUTED
    b8bc:	05c36011 	strbeq	r6, [r3, #17]                              <== NOT EXECUTED
    b8c0:	15c31011 	strbne	r1, [r3, #17]                              <== NOT EXECUTED
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
    b8c4:	e59c8008 	ldr	r8, [ip, #8]                                  <== NOT EXECUTED
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
    b8c8:	e58c200c 	str	r2, [ip, #12]                                 <== NOT EXECUTED
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
    b8cc:	e58c3008 	str	r3, [ip, #8]                                  <== NOT EXECUTED
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
    b8d0:	e583800c 	str	r8, [r3, #12]                                 <== NOT EXECUTED
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
            if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
    b8d4:	e1dc31d1 	ldrsb	r3, [ip, #17]                               <== NOT EXECUTED
    b8d8:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
    b8dc:	05c25011 	strbeq	r5, [r2, #17]                              <== NOT EXECUTED
    b8e0:	0a000000 	beq	b8e8 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== NOT EXECUTED
    b8e4:	e5c21011 	strb	r1, [r2, #17]                                <== NOT EXECUTED
    b8e8:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
            p = p2;                                                   
          }                                                           
          p->avl.bal = 0;                                             
    b8ec:	e5c21011 	strb	r1, [r2, #17]                                <== NOT EXECUTED
    b8f0:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
    b8f4:	ea000001 	b	b900 <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
    b8f8:	e1a02003 	mov	r2, r3                                        
    b8fc:	e3a0c001 	mov	ip, #1                                        
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
    b900:	e1540007 	cmp	r4, r7                                        
    b904:	9a000008 	bls	b92c <rtems_bdbuf_get_buffer_from_lru_list+0x364>
    {                                                                 
      p = *--buf_prev;                                                
    b908:	e5143004 	ldr	r3, [r4, #-4]                                 <== NOT EXECUTED
                                                                      
      if (p->avl.cache == -1)                                         
    b90c:	e1d381d0 	ldrsb	r8, [r3, #16]                               <== NOT EXECUTED
    b910:	e3780001 	cmn	r8, #1                                        <== NOT EXECUTED
      {                                                               
        p->avl.left = q;                                              
    b914:	05832008 	streq	r2, [r3, #8]                                <== NOT EXECUTED
      }                                                               
      else                                                            
      {                                                               
        p->avl.right = q;                                             
    b918:	1583200c 	strne	r2, [r3, #12]                               <== NOT EXECUTED
  q->avl.left = q->avl.right = NULL;                                  
  q->avl.bal = 0;                                                     
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
    b91c:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
        p->avl.right = q;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
    b920:	e2444004 	sub	r4, r4, #4                                    <== NOT EXECUTED
  q->avl.left = q->avl.right = NULL;                                  
  q->avl.bal = 0;                                                     
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
    b924:	1affffac 	bne	b7dc <rtems_bdbuf_get_buffer_from_lru_list+0x214><== NOT EXECUTED
    b928:	ea000001 	b	b934 <rtems_bdbuf_get_buffer_from_lru_list+0x36c><== NOT EXECUTED
        p->avl.right = q;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
    b92c:	e59f3030 	ldr	r3, [pc, #48]	; b964 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
    b930:	e5832040 	str	r2, [r3, #64]	; 0x40                          
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    b934:	e3a03001 	mov	r3, #1                                        
    b938:	e5803024 	str	r3, [r0, #36]	; 0x24                          
                                                                      
    if (empty_bd != NULL)                                             
    {                                                                 
      rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);          
                                                                      
      return empty_bd;                                                
    b93c:	ea000004 	b	b954 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
    b940:	e5988000 	ldr	r8, [r8]                                      
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    b944:	e59f2024 	ldr	r2, [pc, #36]	; b970 <rtems_bdbuf_get_buffer_from_lru_list+0x3a8>
    b948:	e1580002 	cmp	r8, r2                                        
    b94c:	1affff27 	bne	b5f0 <rtems_bdbuf_get_buffer_from_lru_list+0x28>
    b950:	e3a00000 	mov	r0, #0                                        
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
    b954:	e28dd088 	add	sp, sp, #136	; 0x88                           
    b958:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
  bd->avl.left  = NULL;                                               
  bd->avl.right = NULL;                                               
  bd->waiters   = 0;                                                  
                                                                      
  if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)            
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RECYCLE);    
    b95c:	e59f0010 	ldr	r0, [pc, #16]	; b974 <rtems_bdbuf_get_buffer_from_lru_list+0x3ac><== NOT EXECUTED
    b960:	ebffebf5 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

0000a2b0 <rtems_bdbuf_init>: * * @return rtems_status_code The initialisation status. */ rtems_status_code rtems_bdbuf_init (void) {
    a2b0:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  rtems_mode          prev_mode;                                      
                                                                      
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:init\n");                                          
                                                                      
  if (rtems_interrupt_is_in_progress())                               
    a2b4:	e59f33b0 	ldr	r3, [pc, #944]	; a66c <rtems_bdbuf_init+0x3bc>
    a2b8:	e5933000 	ldr	r3, [r3]                                      
    a2bc:	e3530000 	cmp	r3, #0                                        
 *                                                                    
 * @return rtems_status_code The initialisation status.               
 */                                                                   
rtems_status_code                                                     
rtems_bdbuf_init (void)                                               
{                                                                     
    a2c0:	e24dd014 	sub	sp, sp, #20                                   
  rtems_mode          prev_mode;                                      
                                                                      
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:init\n");                                          
                                                                      
  if (rtems_interrupt_is_in_progress())                               
    a2c4:	13a00012 	movne	r0, #18                                     
    a2c8:	1a0000e5 	bne	a664 <rtems_bdbuf_init+0x3b4>                 
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  /*                                                                  
   * Check the configuration table values.                            
   */                                                                 
  if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)       
    a2cc:	e59f739c 	ldr	r7, [pc, #924]	; a670 <rtems_bdbuf_init+0x3c0>
    a2d0:	e5973024 	ldr	r3, [r7, #36]	; 0x24                          
    a2d4:	e5976020 	ldr	r6, [r7, #32]                                 
    a2d8:	e1a00003 	mov	r0, r3                                        
    a2dc:	e1a01006 	mov	r1, r6                                        
    a2e0:	e58d3010 	str	r3, [sp, #16]                                 
    a2e4:	eb0040cd 	bl	1a620 <__umodsi3>                              
    a2e8:	e3500000 	cmp	r0, #0                                        
    a2ec:	13a0000a 	movne	r0, #10                                     
    a2f0:	1a0000db 	bne	a664 <rtems_bdbuf_init+0x3b4>                 
  /*                                                                  
   * We use a special variable to manage the initialisation incase we have
   * completing threads doing this. You may get errors if the another thread
   * makes a call and we have not finished initialisation.            
   */                                                                 
  prev_mode = rtems_bdbuf_disable_preemption ();                      
    a2f4:	ebffffa4 	bl	a18c <rtems_bdbuf_disable_preemption>          
  if (bdbuf_cache.initialised)                                        
    a2f8:	e59f4374 	ldr	r4, [pc, #884]	; a674 <rtems_bdbuf_init+0x3c4>
    a2fc:	e5d45088 	ldrb	r5, [r4, #136]	; 0x88                        
    a300:	e3550000 	cmp	r5, #0                                        
  /*                                                                  
   * We use a special variable to manage the initialisation incase we have
   * completing threads doing this. You may get errors if the another thread
   * makes a call and we have not finished initialisation.            
   */                                                                 
  prev_mode = rtems_bdbuf_disable_preemption ();                      
    a304:	e1a08000 	mov	r8, r0                                        
  if (bdbuf_cache.initialised)                                        
    a308:	0a000002 	beq	a318 <rtems_bdbuf_init+0x68>                  
  {                                                                   
    rtems_bdbuf_restore_preemption (prev_mode);                       
    a30c:	ebffffac 	bl	a1c4 <rtems_bdbuf_restore_preemption>          <== NOT EXECUTED
    a310:	e3a0000c 	mov	r0, #12                                       <== NOT EXECUTED
    return RTEMS_RESOURCE_IN_USE;                                     
    a314:	ea0000d2 	b	a664 <rtems_bdbuf_init+0x3b4>                   <== NOT EXECUTED
  }                                                                   
                                                                      
  memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));                       
    a318:	e1a01005 	mov	r1, r5                                        
    a31c:	e3a0208c 	mov	r2, #140	; 0x8c                               
    a320:	e1a00004 	mov	r0, r4                                        
    a324:	eb001d53 	bl	11878 <memset>                                 
  bdbuf_cache.initialised = true;                                     
  rtems_bdbuf_restore_preemption (prev_mode);                         
    a328:	e1a00008 	mov	r0, r8                                        
    rtems_bdbuf_restore_preemption (prev_mode);                       
    return RTEMS_RESOURCE_IN_USE;                                     
  }                                                                   
                                                                      
  memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));                       
  bdbuf_cache.initialised = true;                                     
    a32c:	e3a08001 	mov	r8, #1                                        
    a330:	e5c48088 	strb	r8, [r4, #136]	; 0x88                        
  rtems_bdbuf_restore_preemption (prev_mode);                         
    a334:	ebffffa2 	bl	a1c4 <rtems_bdbuf_restore_preemption>          
   */                                                                 
  cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */   
  if (cache_aligment <= 0)                                            
    cache_aligment = CPU_ALIGNMENT;                                   
                                                                      
  bdbuf_cache.sync_device = BDBUF_INVALID_DEV;                        
    a338:	e3e0a000 	mvn	sl, #0                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    a33c:	e284c00c 	add	ip, r4, #12                                   
    a340:	e3e0b000 	mvn	fp, #0                                        
    a344:	e584a038 	str	sl, [r4, #56]	; 0x38                          
    a348:	e584b03c 	str	fp, [r4, #60]	; 0x3c                          
    a34c:	e584c008 	str	ip, [r4, #8]                                  
    a350:	e59fb320 	ldr	fp, [pc, #800]	; a678 <rtems_bdbuf_init+0x3c8>
    a354:	e59fc320 	ldr	ip, [pc, #800]	; a67c <rtems_bdbuf_init+0x3cc>
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    a358:	e59fa320 	ldr	sl, [pc, #800]	; a680 <rtems_bdbuf_init+0x3d0>
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    a35c:	e584b044 	str	fp, [r4, #68]	; 0x44                          
    a360:	e584c050 	str	ip, [r4, #80]	; 0x50                          
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    a364:	e584a058 	str	sl, [r4, #88]	; 0x58                          
    a368:	e59fc314 	ldr	ip, [pc, #788]	; a684 <rtems_bdbuf_init+0x3d4>
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    a36c:	e59fb314 	ldr	fp, [pc, #788]	; a688 <rtems_bdbuf_init+0x3d8>
  rtems_chain_initialize_empty (&bdbuf_cache.sync);                   
                                                                      
  /*                                                                  
   * Create the locks for the cache.                                  
   */                                                                 
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'), 
    a370:	e59fa314 	ldr	sl, [pc, #788]	; a68c <rtems_bdbuf_init+0x3dc>
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    a374:	e284e008 	add	lr, r4, #8                                    
    a378:	e2849044 	add	r9, r4, #68	; 0x44                            
    a37c:	e1a03005 	mov	r3, r5                                        
    a380:	e584e010 	str	lr, [r4, #16]                                 
    a384:	e584904c 	str	r9, [r4, #76]	; 0x4c                          
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    a388:	e584b05c 	str	fp, [r4, #92]	; 0x5c                          
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    a38c:	e584c064 	str	ip, [r4, #100]	; 0x64                         
    a390:	e59f02f8 	ldr	r0, [pc, #760]	; a690 <rtems_bdbuf_init+0x3e0>
    a394:	e58da000 	str	sl, [sp]                                      
    a398:	e1a01008 	mov	r1, r8                                        
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
    a39c:	e584500c 	str	r5, [r4, #12]                                 
    a3a0:	e5845048 	str	r5, [r4, #72]	; 0x48                          
    a3a4:	e5845054 	str	r5, [r4, #84]	; 0x54                          
    a3a8:	e5845060 	str	r5, [r4, #96]	; 0x60                          
    a3ac:	e3a02054 	mov	r2, #84	; 0x54                                
    a3b0:	ebffef61 	bl	613c <rtems_semaphore_create>                  
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.lock);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
    a3b4:	e2505000 	subs	r5, r0, #0                                   
    a3b8:	1a00008c 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    a3bc:	ebfffe2e 	bl	9c7c <rtems_bdbuf_lock_cache>                  
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'), 
    a3c0:	e1a01008 	mov	r1, r8                                        
    a3c4:	e284c02c 	add	ip, r4, #44	; 0x2c                            
    a3c8:	e1a03005 	mov	r3, r5                                        
    a3cc:	e59f02c0 	ldr	r0, [pc, #704]	; a694 <rtems_bdbuf_init+0x3e4>
    a3d0:	e3a02054 	mov	r2, #84	; 0x54                                
    a3d4:	e58dc000 	str	ip, [sp]                                      
    a3d8:	ebffef57 	bl	613c <rtems_semaphore_create>                  
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.sync_lock);               
  if (sc != RTEMS_SUCCESSFUL)                                         
    a3dc:	e2501000 	subs	r1, r0, #0                                   
    a3e0:	1a000082 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'), 
    a3e4:	e284c06c 	add	ip, r4, #108	; 0x6c                           
    a3e8:	e1a03001 	mov	r3, r1                                        
    a3ec:	e59f02a4 	ldr	r0, [pc, #676]	; a698 <rtems_bdbuf_init+0x3e8>
    a3f0:	e3a02024 	mov	r2, #36	; 0x24                                
    a3f4:	e58dc000 	str	ip, [sp]                                      
    a3f8:	ebffef4f 	bl	613c <rtems_semaphore_create>                  
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.access_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
    a3fc:	e2501000 	subs	r1, r0, #0                                   
    a400:	1a00007a 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'), 
    a404:	e284c074 	add	ip, r4, #116	; 0x74                           
    a408:	e1a03001 	mov	r3, r1                                        
    a40c:	e59f0288 	ldr	r0, [pc, #648]	; a69c <rtems_bdbuf_init+0x3ec>
    a410:	e3a02024 	mov	r2, #36	; 0x24                                
    a414:	e58dc000 	str	ip, [sp]                                      
    a418:	ebffef47 	bl	613c <rtems_semaphore_create>                  
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.transfer_waiters.sema);   
  if (sc != RTEMS_SUCCESSFUL)                                         
    a41c:	e2501000 	subs	r1, r0, #0                                   
    a420:	1a000072 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'), 
    a424:	e284c07c 	add	ip, r4, #124	; 0x7c                           
    a428:	e59f0270 	ldr	r0, [pc, #624]	; a6a0 <rtems_bdbuf_init+0x3f0>
    a42c:	e3a02024 	mov	r2, #36	; 0x24                                
    a430:	e1a03001 	mov	r3, r1                                        
    a434:	e58dc000 	str	ip, [sp]                                      
    a438:	ebffef3f 	bl	613c <rtems_semaphore_create>                  
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.buffer_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
    a43c:	e3500000 	cmp	r0, #0                                        
    a440:	1a00006a 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
    a444:	e597001c 	ldr	r0, [r7, #28]                                 
    a448:	e1a01006 	mov	r1, r6                                        
    a44c:	eb003fdf 	bl	1a3d0 <__aeabi_uidiv>                          
    a450:	e1a05000 	mov	r5, r0                                        
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
    a454:	e1a01006 	mov	r1, r6                                        
    a458:	e59d0010 	ldr	r0, [sp, #16]                                 
    goto error;                                                       
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    a45c:	e584501c 	str	r5, [r4, #28]                                 
    bdbuf_config.size / bdbuf_config.buffer_min;                      
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
    a460:	eb003fda 	bl	1a3d0 <__aeabi_uidiv>                          
    a464:	e1a03000 	mov	r3, r0                                        
  bdbuf_cache.group_count =                                           
    a468:	e1a01000 	mov	r1, r0                                        
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
  bdbuf_cache.max_bds_per_group =                                     
    a46c:	e5843020 	str	r3, [r4, #32]                                 
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
  bdbuf_cache.group_count =                                           
    a470:	e1a00005 	mov	r0, r5                                        
    a474:	eb003fd5 	bl	1a3d0 <__aeabi_uidiv>                          
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
    a478:	e1a01005 	mov	r1, r5                                        
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
  bdbuf_cache.group_count =                                           
    a47c:	e5840080 	str	r0, [r4, #128]	; 0x80                         
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
    a480:	e3a0003c 	mov	r0, #60	; 0x3c                                
    a484:	ebffe1c4 	bl	2b9c <calloc>                                  
                            bdbuf_cache.buffer_min_count);            
  if (!bdbuf_cache.bds)                                               
    a488:	e3500000 	cmp	r0, #0                                        
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
    a48c:	e5840014 	str	r0, [r4, #20]                                 
                            bdbuf_cache.buffer_min_count);            
  if (!bdbuf_cache.bds)                                               
    a490:	0a000056 	beq	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),            
    a494:	e3a00014 	mov	r0, #20                                       
    a498:	e5941080 	ldr	r1, [r4, #128]	; 0x80                         
    a49c:	ebffe1be 	bl	2b9c <calloc>                                  
                               bdbuf_cache.group_count);              
  if (!bdbuf_cache.groups)                                            
    a4a0:	e3500000 	cmp	r0, #0                                        
    goto error;                                                       
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),            
    a4a4:	e5840084 	str	r0, [r4, #132]	; 0x84                         
                               bdbuf_cache.group_count);              
  if (!bdbuf_cache.groups)                                            
    a4a8:	0a000050 	beq	a5f0 <rtems_bdbuf_init+0x340>                 
   * aligned. It is possible to free the memory allocated by rtems_memalign()
   * with free(). Return 0 if allocated.                              
   *                                                                  
   * The memory allocate allows a                                     
   */                                                                 
  if (rtems_memalign ((void **) &bdbuf_cache.buffers,                 
    a4ac:	e59f71c0 	ldr	r7, [pc, #448]	; a674 <rtems_bdbuf_init+0x3c4>
    a4b0:	e597201c 	ldr	r2, [r7, #28]                                 
    a4b4:	e2870018 	add	r0, r7, #24                                   
    a4b8:	e0020296 	mul	r2, r6, r2                                    
    a4bc:	e3a01020 	mov	r1, #32                                       
    a4c0:	eb000f5c 	bl	e238 <rtems_memalign>                          
    a4c4:	e2505000 	subs	r5, r0, #0                                   
    a4c8:	1a000048 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
                                                                      
  /*                                                                  
   * The cache is empty after opening so we need to add all the buffers to it
   * and initialise the groups.                                       
   */                                                                 
  for (b = 0, group = bdbuf_cache.groups,                             
    a4cc:	e1a0a007 	mov	sl, r7                                        
    a4d0:	e5978084 	ldr	r8, [r7, #132]	; 0x84                         
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
    a4d4:	e5974014 	ldr	r4, [r7, #20]                                 
       b < bdbuf_cache.buffer_min_count;                              
       b++, bd++, buffer += bdbuf_config.buffer_min)                  
  {                                                                   
    bd->dev    = BDBUF_INVALID_DEV;                                   
    a4d8:	e3e02000 	mvn	r2, #0                                        
  /*                                                                  
   * The cache is empty after opening so we need to add all the buffers to it
   * and initialise the groups.                                       
   */                                                                 
  for (b = 0, group = bdbuf_cache.groups,                             
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
    a4dc:	e5977018 	ldr	r7, [r7, #24]                                 
       b < bdbuf_cache.buffer_min_count;                              
       b++, bd++, buffer += bdbuf_config.buffer_min)                  
  {                                                                   
    bd->dev    = BDBUF_INVALID_DEV;                                   
    a4e0:	e3e03000 	mvn	r3, #0                                        
    a4e4:	e1a09006 	mov	r9, r6                                        
                                                                      
  /*                                                                  
   * The cache is empty after opening so we need to add all the buffers to it
   * and initialise the groups.                                       
   */                                                                 
  for (b = 0, group = bdbuf_cache.groups,                             
    a4e8:	ea000012 	b	a538 <rtems_bdbuf_init+0x288>                   
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
       b < bdbuf_cache.buffer_min_count;                              
       b++, bd++, buffer += bdbuf_config.buffer_min)                  
  {                                                                   
    bd->dev    = BDBUF_INVALID_DEV;                                   
    a4ec:	e5842014 	str	r2, [r4, #20]                                 
    a4f0:	e5843018 	str	r3, [r4, #24]                                 
    bd->group  = group;                                               
    a4f4:	e584802c 	str	r8, [r4, #44]	; 0x2c                          
    bd->buffer = buffer;                                              
    a4f8:	e5847020 	str	r7, [r4, #32]                                 
    a4fc:	e58d200c 	str	r2, [sp, #12]                                 
    a500:	e58d3008 	str	r3, [sp, #8]                                  
    a504:	ebfff22d 	bl	6dc0 <_Chain_Append>                           
                                                                      
    rtems_chain_append (&bdbuf_cache.lru, &bd->link);                 
                                                                      
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
    a508:	e59a6020 	ldr	r6, [sl, #32]                                 
    a50c:	e1a00005 	mov	r0, r5                                        
    a510:	e1a01006 	mov	r1, r6                                        
    a514:	eb004041 	bl	1a620 <__umodsi3>                              
    a518:	e2466001 	sub	r6, r6, #1                                    
    a51c:	e1500006 	cmp	r0, r6                                        
    a520:	e59d200c 	ldr	r2, [sp, #12]                                 
    a524:	e59d3008 	ldr	r3, [sp, #8]                                  
        (bdbuf_cache.max_bds_per_group - 1))                          
      group++;                                                        
    a528:	02888014 	addeq	r8, r8, #20                                 
   * and initialise the groups.                                       
   */                                                                 
  for (b = 0, group = bdbuf_cache.groups,                             
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
       b < bdbuf_cache.buffer_min_count;                              
       b++, bd++, buffer += bdbuf_config.buffer_min)                  
    a52c:	e2855001 	add	r5, r5, #1                                    
    a530:	e284403c 	add	r4, r4, #60	; 0x3c                            
    a534:	e0877009 	add	r7, r7, r9                                    
                                                                      
  /*                                                                  
   * The cache is empty after opening so we need to add all the buffers to it
   * and initialise the groups.                                       
   */                                                                 
  for (b = 0, group = bdbuf_cache.groups,                             
    a538:	e59a001c 	ldr	r0, [sl, #28]                                 
    a53c:	e59fc130 	ldr	ip, [pc, #304]	; a674 <rtems_bdbuf_init+0x3c4>
    a540:	e1550000 	cmp	r5, r0                                        
    a544:	e1a01004 	mov	r1, r4                                        
    a548:	e28c0044 	add	r0, ip, #68	; 0x44                            
    a54c:	3affffe6 	bcc	a4ec <rtems_bdbuf_init+0x23c>                 
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
    a550:	e59c0020 	ldr	r0, [ip, #32]                                 
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
    a554:	e3a0303c 	mov	r3, #60	; 0x3c                                
    a558:	e00e0093 	mul	lr, r3, r0                                    
      group++;                                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
    a55c:	e59c1014 	ldr	r1, [ip, #20]                                 
        (bdbuf_cache.max_bds_per_group - 1))                          
      group++;                                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
    a560:	e59c3084 	ldr	r3, [ip, #132]	; 0x84                         
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
    a564:	e3a02000 	mov	r2, #0                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
    a568:	e59cc080 	ldr	ip, [ip, #128]	; 0x80                         
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
        (bdbuf_cache.max_bds_per_group - 1))                          
      group++;                                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
    a56c:	ea000004 	b	a584 <rtems_bdbuf_init+0x2d4>                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
    group->bdbuf = bd;                                                
    a570:	e5831010 	str	r1, [r3, #16]                                 
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
    a574:	e5830008 	str	r0, [r3, #8]                                  
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
    a578:	e2822001 	add	r2, r2, #1                                    
         group++,                                                     
    a57c:	e2833014 	add	r3, r3, #20                                   
         bd += bdbuf_cache.max_bds_per_group)                         
    a580:	e081100e 	add	r1, r1, lr                                    
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
        (bdbuf_cache.max_bds_per_group - 1))                          
      group++;                                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
    a584:	e152000c 	cmp	r2, ip                                        
    a588:	3afffff8 	bcc	a570 <rtems_bdbuf_init+0x2c0>                 
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
                                                                      
  sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),       
                          bdbuf_config.swapout_priority ?             
    a58c:	e59f30dc 	ldr	r3, [pc, #220]	; a670 <rtems_bdbuf_init+0x3c0>
    a590:	e5931008 	ldr	r1, [r3, #8]                                  
                                                                      
  /*                                                                  
   * Create and start swapout task. This task will create and manage the worker
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
    a594:	e59f40d8 	ldr	r4, [pc, #216]	; a674 <rtems_bdbuf_init+0x3c4>
                                                                      
  sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),       
    a598:	e3510000 	cmp	r1, #0                                        
                                                                      
  /*                                                                  
   * Create and start swapout task. This task will create and manage the worker
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
    a59c:	e3a0c001 	mov	ip, #1                                        
    a5a0:	e5c4c004 	strb	ip, [r4, #4]                                 
                                                                      
  sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),       
    a5a4:	03a0100f 	moveq	r1, #15                                     
    a5a8:	e3a0c000 	mov	ip, #0                                        
    a5ac:	e59f00f0 	ldr	r0, [pc, #240]	; a6a4 <rtems_bdbuf_init+0x3f4>
    a5b0:	e3a02a02 	mov	r2, #8192	; 0x2000                            
    a5b4:	e3a03b01 	mov	r3, #1024	; 0x400                             
    a5b8:	e58dc000 	str	ip, [sp]                                      
    a5bc:	e58d4004 	str	r4, [sp, #4]                                  
    a5c0:	ebffefdc 	bl	6538 <rtems_task_create>                       
                            RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
                          SWAPOUT_TASK_STACK_SIZE,                    
                          RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
                          RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,      
                          &bdbuf_cache.swapout);                      
  if (sc != RTEMS_SUCCESSFUL)                                         
    a5c4:	e3500000 	cmp	r0, #0                                        
    a5c8:	1a000008 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  sc = rtems_task_start (bdbuf_cache.swapout,                         
    a5cc:	e1a02004 	mov	r2, r4                                        
    a5d0:	e5940000 	ldr	r0, [r4]                                      
    a5d4:	e59f10cc 	ldr	r1, [pc, #204]	; a6a8 <rtems_bdbuf_init+0x3f8>
    a5d8:	ebfff066 	bl	6778 <rtems_task_start>                        
                         rtems_bdbuf_swapout_task,                    
                         (rtems_task_argument) &bdbuf_cache);         
  if (sc != RTEMS_SUCCESSFUL)                                         
    a5dc:	e2504000 	subs	r4, r0, #0                                   
    a5e0:	1a000002 	bne	a5f0 <rtems_bdbuf_init+0x340>                 
    goto error;                                                       
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    a5e4:	ebfffe1d 	bl	9e60 <rtems_bdbuf_unlock_cache>                
    a5e8:	e1a00004 	mov	r0, r4                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
    a5ec:	ea00001c 	b	a664 <rtems_bdbuf_init+0x3b4>                   
                                                                      
error:                                                                
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
    a5f0:	e59f307c 	ldr	r3, [pc, #124]	; a674 <rtems_bdbuf_init+0x3c4><== NOT EXECUTED
    a5f4:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    a5f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.swapout);                          
    a5fc:	1bfff01f 	blne	6680 <rtems_task_delete>                     <== NOT EXECUTED
                                                                      
  free (bdbuf_cache.buffers);                                         
    a600:	e59f406c 	ldr	r4, [pc, #108]	; a674 <rtems_bdbuf_init+0x3c4><== NOT EXECUTED
    a604:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
    a608:	ebffe1eb 	bl	2dbc <free>                                    <== NOT EXECUTED
  free (bdbuf_cache.groups);                                          
    a60c:	e5940084 	ldr	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
    a610:	ebffe1e9 	bl	2dbc <free>                                    <== NOT EXECUTED
  free (bdbuf_cache.bds);                                             
    a614:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
    a618:	ebffe1e7 	bl	2dbc <free>                                    <== NOT EXECUTED
                                                                      
  rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);           
    a61c:	e594007c 	ldr	r0, [r4, #124]	; 0x7c                         <== NOT EXECUTED
    a620:	ebffef30 	bl	62e8 <rtems_semaphore_delete>                  <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);           
    a624:	e594006c 	ldr	r0, [r4, #108]	; 0x6c                         <== NOT EXECUTED
    a628:	ebffef2e 	bl	62e8 <rtems_semaphore_delete>                  <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);         
    a62c:	e5940074 	ldr	r0, [r4, #116]	; 0x74                         <== NOT EXECUTED
    a630:	ebffef2c 	bl	62e8 <rtems_semaphore_delete>                  <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.sync_lock);                     
    a634:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
    a638:	ebffef2a 	bl	62e8 <rtems_semaphore_delete>                  <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.lock != 0)                                          
    a63c:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    a640:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    a644:	0a000002 	beq	a654 <rtems_bdbuf_init+0x3a4>                 <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
    a648:	ebfffe04 	bl	9e60 <rtems_bdbuf_unlock_cache>                <== NOT EXECUTED
    rtems_semaphore_delete (bdbuf_cache.lock);                        
    a64c:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    a650:	ebffef24 	bl	62e8 <rtems_semaphore_delete>                  <== NOT EXECUTED
  }                                                                   
                                                                      
  bdbuf_cache.initialised = false;                                    
    a654:	e59f3018 	ldr	r3, [pc, #24]	; a674 <rtems_bdbuf_init+0x3c4> <== NOT EXECUTED
    a658:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    a65c:	e5c32088 	strb	r2, [r3, #136]	; 0x88                        <== NOT EXECUTED
    a660:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
                                                                      
  return RTEMS_UNSATISFIED;                                           
}                                                                     
    a664:	e28dd014 	add	sp, sp, #20                                   
    a668:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
                                                                      

00009c58 <rtems_bdbuf_lock>: * @param lock The mutex to lock. * @param fatal_error_code The error code if the call fails. */ static void rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code) {
    9c58:	e92d4010 	push	{r4, lr}                                     
    9c5c:	e1a04001 	mov	r4, r1                                        
  rtems_status_code sc = rtems_semaphore_obtain (lock,                
    9c60:	e3a01000 	mov	r1, #0                                        
    9c64:	e1a02001 	mov	r2, r1                                        
    9c68:	ebfff1c5 	bl	6384 <rtems_semaphore_obtain>                  
                                                 RTEMS_WAIT,          
                                                 RTEMS_NO_TIMEOUT);   
  if (sc != RTEMS_SUCCESSFUL)                                         
    9c6c:	e3500000 	cmp	r0, #0                                        
    9c70:	08bd8010 	popeq	{r4, pc}                                    
    rtems_fatal_error_occurred (fatal_error_code);                    
    9c74:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    9c78:	ebfff32f 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

00009eb0 <rtems_bdbuf_obtain_disk>: rtems_blkdev_bnum *media_block_ptr, size_t *bds_per_group_ptr) { rtems_disk_device *dd = NULL; if (!bdbuf_cache.initialised)
    9eb0:	e59fc0e4 	ldr	ip, [pc, #228]	; 9f9c <rtems_bdbuf_obtain_disk+0xec>
    9eb4:	e5dcc088 	ldrb	ip, [ip, #136]	; 0x88                        
rtems_bdbuf_obtain_disk (dev_t               dev,                     
                         rtems_blkdev_bnum   block,                   
                         rtems_disk_device **dd_ptr,                  
                         rtems_blkdev_bnum  *media_block_ptr,         
                         size_t             *bds_per_group_ptr)       
{                                                                     
    9eb8:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  rtems_disk_device *dd = NULL;                                       
                                                                      
  if (!bdbuf_cache.initialised)                                       
    9ebc:	e35c0000 	cmp	ip, #0                                        
rtems_bdbuf_obtain_disk (dev_t               dev,                     
                         rtems_blkdev_bnum   block,                   
                         rtems_disk_device **dd_ptr,                  
                         rtems_blkdev_bnum  *media_block_ptr,         
                         size_t             *bds_per_group_ptr)       
{                                                                     
    9ec0:	e1a07002 	mov	r7, r2                                        
    9ec4:	e1a08003 	mov	r8, r3                                        
    9ec8:	e59d6018 	ldr	r6, [sp, #24]                                 
    9ecc:	e59d501c 	ldr	r5, [sp, #28]                                 
  rtems_disk_device *dd = NULL;                                       
                                                                      
  if (!bdbuf_cache.initialised)                                       
    9ed0:	03a00016 	moveq	r0, #22                                     
    9ed4:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    
    return RTEMS_NOT_CONFIGURED;                                      
                                                                      
  /*                                                                  
   * Do not hold the cache lock when obtaining the disk table.        
   */                                                                 
  dd = rtems_disk_obtain (dev);                                       
    9ed8:	ebffdfeb 	bl	1e8c <rtems_disk_obtain>                       
  if (dd == NULL)                                                     
    9edc:	e2504000 	subs	r4, r0, #0                                   
    9ee0:	02800004 	addeq	r0, r0, #4                                  
    9ee4:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    
    return RTEMS_INVALID_ID;                                          
                                                                      
  *dd_ptr = dd;                                                       
                                                                      
  if (media_block_ptr != NULL)                                        
    9ee8:	e3560000 	cmp	r6, #0                                        
   */                                                                 
  dd = rtems_disk_obtain (dev);                                       
  if (dd == NULL)                                                     
    return RTEMS_INVALID_ID;                                          
                                                                      
  *dd_ptr = dd;                                                       
    9eec:	e5884000 	str	r4, [r8]                                      
                                                                      
  if (media_block_ptr != NULL)                                        
    9ef0:	0a00000c 	beq	9f28 <rtems_bdbuf_obtain_disk+0x78>           
static rtems_blkdev_bnum                                              
rtems_bdbuf_media_block (rtems_blkdev_bnum block,                     
                         size_t            block_size,                
                         size_t            media_block_size)          
{                                                                     
  return (rtems_blkdev_bnum)                                          
    9ef4:	e5940020 	ldr	r0, [r4, #32]                                 
    9ef8:	e0832097 	umull	r2, r3, r7, r0                              
    9efc:	e1a00002 	mov	r0, r2                                        
    9f00:	e1a01003 	mov	r1, r3                                        
    9f04:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          
    9f08:	e3a03000 	mov	r3, #0                                        
    9f0c:	eb0046dc 	bl	1ba84 <__udivdi3>                              
     * the user.                                                      
     */                                                               
    rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,            
                                                    dd->block_size,   
                                                    dd->media_block_size);
    if (mb >= dd->size)                                               
    9f10:	e594301c 	ldr	r3, [r4, #28]                                 
    9f14:	e1500003 	cmp	r0, r3                                        
    {                                                                 
      rtems_disk_release(dd);                                         
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    *media_block_ptr = mb + dd->start;                                
    9f18:	35943018 	ldrcc	r3, [r4, #24]                               
    9f1c:	30800003 	addcc	r0, r0, r3                                  
    9f20:	35860000 	strcc	r0, [r6]                                    
     * the user.                                                      
     */                                                               
    rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,            
                                                    dd->block_size,   
                                                    dd->media_block_size);
    if (mb >= dd->size)                                               
    9f24:	2a000015 	bcs	9f80 <rtems_bdbuf_obtain_disk+0xd0>           
    }                                                                 
                                                                      
    *media_block_ptr = mb + dd->start;                                
  }                                                                   
                                                                      
  if (bds_per_group_ptr != NULL)                                      
    9f28:	e3550000 	cmp	r5, #0                                        
    9f2c:	01a00005 	moveq	r0, r5                                      
    9f30:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    
rtems_bdbuf_bds_per_group (size_t size)                               
{                                                                     
  size_t bufs_per_size;                                               
  size_t bds_per_size;                                                
                                                                      
  if (size > bdbuf_config.buffer_max)                                 
    9f34:	e59f3064 	ldr	r3, [pc, #100]	; 9fa0 <rtems_bdbuf_obtain_disk+0xf0>
    *media_block_ptr = mb + dd->start;                                
  }                                                                   
                                                                      
  if (bds_per_group_ptr != NULL)                                      
  {                                                                   
    size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
    9f38:	e5940020 	ldr	r0, [r4, #32]                                 
rtems_bdbuf_bds_per_group (size_t size)                               
{                                                                     
  size_t bufs_per_size;                                               
  size_t bds_per_size;                                                
                                                                      
  if (size > bdbuf_config.buffer_max)                                 
    9f3c:	e5932024 	ldr	r2, [r3, #36]	; 0x24                          
    9f40:	e1500002 	cmp	r0, r2                                        
    9f44:	8a00000d 	bhi	9f80 <rtems_bdbuf_obtain_disk+0xd0>           
    return 0;                                                         
                                                                      
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;         
    9f48:	e5931020 	ldr	r1, [r3, #32]                                 
    9f4c:	e2400001 	sub	r0, r0, #1                                    
    9f50:	eb00411e 	bl	1a3d0 <__aeabi_uidiv>                          
    9f54:	e3a01001 	mov	r1, #1                                        
    9f58:	e2800001 	add	r0, r0, #1                                    
    9f5c:	ea000000 	b	9f64 <rtems_bdbuf_obtain_disk+0xb4>             
                                                                      
  for (bds_per_size = 1;                                              
       bds_per_size < bufs_per_size;                                  
       bds_per_size <<= 1)                                            
    9f60:	e1a01081 	lsl	r1, r1, #1                                    
  if (size > bdbuf_config.buffer_max)                                 
    return 0;                                                         
                                                                      
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;         
                                                                      
  for (bds_per_size = 1;                                              
    9f64:	e1510000 	cmp	r1, r0                                        
    9f68:	3afffffc 	bcc	9f60 <rtems_bdbuf_obtain_disk+0xb0>           
       bds_per_size < bufs_per_size;                                  
       bds_per_size <<= 1)                                            
    ;                                                                 
                                                                      
  return bdbuf_cache.max_bds_per_group / bds_per_size;                
    9f6c:	e59f3028 	ldr	r3, [pc, #40]	; 9f9c <rtems_bdbuf_obtain_disk+0xec>
    9f70:	e5930020 	ldr	r0, [r3, #32]                                 
    9f74:	eb004115 	bl	1a3d0 <__aeabi_uidiv>                          
                                                                      
  if (bds_per_group_ptr != NULL)                                      
  {                                                                   
    size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
                                                                      
    if (bds_per_group == 0)                                           
    9f78:	e3500000 	cmp	r0, #0                                        
    9f7c:	1a000003 	bne	9f90 <rtems_bdbuf_obtain_disk+0xe0>           
    {                                                                 
      rtems_disk_release (dd);                                        
    9f80:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    9f84:	ebffe03c 	bl	207c <rtems_disk_release>                      <== NOT EXECUTED
    9f88:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
    9f8c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    }                                                                 
                                                                      
    *bds_per_group_ptr = bds_per_group;                               
    9f90:	e5850000 	str	r0, [r5]                                      
    9f94:	e3a00000 	mov	r0, #0                                        
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    9f98:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

0000ac60 <rtems_bdbuf_purge>: } } static void rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev) {
    ac60:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
    ac64:	e24dd094 	sub	sp, sp, #148	; 0x94                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    ac68:	e28d6088 	add	r6, sp, #136	; 0x88                           
  the_chain->permanent_null = NULL;                                   
    ac6c:	e3a04000 	mov	r4, #0                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    ac70:	e2863004 	add	r3, r6, #4                                    
    ac74:	e58d3088 	str	r3, [sp, #136]	; 0x88                         
  the_chain->permanent_null = NULL;                                   
    ac78:	e58d408c 	str	r4, [sp, #140]	; 0x8c                         
    ac7c:	e1a07000 	mov	r7, r0                                        
  the_chain->last           = _Chain_Head(the_chain);                 
    ac80:	e58d6090 	str	r6, [sp, #144]	; 0x90                         
    ac84:	e88d0006 	stm	sp, {r1, r2}                                  
  rtems_chain_control purge_list;                                     
                                                                      
  rtems_chain_initialize_empty (&purge_list);                         
  rtems_bdbuf_lock_cache ();                                          
    ac88:	ebfffbfb 	bl	9c7c <rtems_bdbuf_lock_cache>                  
                              rtems_bdbuf_purge_compare compare,      
                              dev_t dev)                              
{                                                                     
  rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];             
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
    ac8c:	e59f3158 	ldr	r3, [pc, #344]	; adec <rtems_bdbuf_purge+0x18c>
                                                                      
  *prev = NULL;                                                       
    ac90:	e28d5094 	add	r5, sp, #148	; 0x94                           
    ac94:	e525408c 	str	r4, [r5, #-140]!	; 0x8c                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    ac98:	e3a08006 	mov	r8, #6                                        
                              rtems_bdbuf_purge_compare compare,      
                              dev_t dev)                              
{                                                                     
  rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];             
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
    ac9c:	e5934040 	ldr	r4, [r3, #64]	; 0x40                          
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    aca0:	e3a0a00a 	mov	sl, #10                                       
    aca4:	ea00003c 	b	ad9c <rtems_bdbuf_purge+0x13c>                  
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if ((*compare) (cur->dev, dev))                                   
    aca8:	e2841014 	add	r1, r4, #20                                   
    acac:	e8910003 	ldm	r1, {r0, r1}                                  
    acb0:	e89d000c 	ldm	sp, {r2, r3}                                  
    acb4:	e1a0e00f 	mov	lr, pc                                        
    acb8:	e12fff17 	bx	r7                                             
    acbc:	e3500000 	cmp	r0, #0                                        
    acc0:	0a000020 	beq	ad48 <rtems_bdbuf_purge+0xe8>                 
    {                                                                 
      switch (cur->state)                                             
    acc4:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
    acc8:	e353000a 	cmp	r3, #10                                       
    accc:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
    acd0:	ea00001a 	b	ad40 <rtems_bdbuf_purge+0xe0>                   <== NOT EXECUTED
    acd4:	0000ad48 	.word	0x0000ad48                                  <== NOT EXECUTED
    acd8:	0000ad48 	.word	0x0000ad48                                  <== NOT EXECUTED
    acdc:	0000ad18 	.word	0x0000ad18                                  <== NOT EXECUTED
    ace0:	0000ad38 	.word	0x0000ad38                                  <== NOT EXECUTED
    ace4:	0000ad38 	.word	0x0000ad38                                  <== NOT EXECUTED
    ace8:	0000ad38 	.word	0x0000ad38                                  <== NOT EXECUTED
    acec:	0000ad48 	.word	0x0000ad48                                  <== NOT EXECUTED
    acf0:	0000ad08 	.word	0x0000ad08                                  <== NOT EXECUTED
    acf4:	0000ad00 	.word	0x0000ad00                                  <== NOT EXECUTED
    acf8:	0000ad30 	.word	0x0000ad30                                  <== NOT EXECUTED
    acfc:	0000ad48 	.word	0x0000ad48                                  <== NOT EXECUTED
        case RTEMS_BDBUF_STATE_EMPTY:                                 
        case RTEMS_BDBUF_STATE_ACCESS_PURGED:                         
        case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                       
          break;                                                      
        case RTEMS_BDBUF_STATE_SYNC:                                  
          rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);           
    ad00:	e59f00e8 	ldr	r0, [pc, #232]	; adf0 <rtems_bdbuf_purge+0x190>
    ad04:	ebfffbe2 	bl	9c94 <rtems_bdbuf_wake>                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
    ad08:	e594302c 	ldr	r3, [r4, #44]	; 0x2c                          
    ad0c:	e593200c 	ldr	r2, [r3, #12]                                 
    ad10:	e2422001 	sub	r2, r2, #1                                    
    ad14:	e583200c 	str	r2, [r3, #12]                                 
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
    ad18:	e1a00004 	mov	r0, r4                                        
    ad1c:	ebfff032 	bl	6dec <_Chain_Extract>                          
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
    ad20:	e1a00006 	mov	r0, r6                                        
    ad24:	e1a01004 	mov	r1, r4                                        
    ad28:	ebfff024 	bl	6dc0 <_Chain_Append>                           
    ad2c:	ea000005 	b	ad48 <rtems_bdbuf_purge+0xe8>                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    ad30:	e584a024 	str	sl, [r4, #36]	; 0x24                          
    ad34:	ea000003 	b	ad48 <rtems_bdbuf_purge+0xe8>                   
    ad38:	e5848024 	str	r8, [r4, #36]	; 0x24                          
    ad3c:	ea000001 	b	ad48 <rtems_bdbuf_purge+0xe8>                   
        case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                          
        case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                       
          rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
          break;                                                      
        default:                                                      
          rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
    ad40:	e59f00ac 	ldr	r0, [pc, #172]	; adf4 <rtems_bdbuf_purge+0x194><== NOT EXECUTED
    ad44:	ebffeefc 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    if (cur->avl.left != NULL)                                        
    ad48:	e5943008 	ldr	r3, [r4, #8]                                  
    ad4c:	e3530000 	cmp	r3, #0                                        
    {                                                                 
      /* Left */                                                      
      ++prev;                                                         
      *prev = cur;                                                    
    ad50:	15a54004 	strne	r4, [r5, #4]!                               
      cur = cur->avl.left;                                            
    ad54:	15943008 	ldrne	r3, [r4, #8]                                
        default:                                                      
          rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
      }                                                               
    }                                                                 
                                                                      
    if (cur->avl.left != NULL)                                        
    ad58:	1a00000e 	bne	ad98 <rtems_bdbuf_purge+0x138>                
      /* Left */                                                      
      ++prev;                                                         
      *prev = cur;                                                    
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    ad5c:	e594300c 	ldr	r3, [r4, #12]                                 
    ad60:	e3530000 	cmp	r3, #0                                        
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
      *prev = cur;                                                    
    ad64:	15a54004 	strne	r4, [r5, #4]!                               
      cur = cur->avl.right;                                           
    ad68:	1594300c 	ldrne	r3, [r4, #12]                               
      /* Left */                                                      
      ++prev;                                                         
      *prev = cur;                                                    
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    ad6c:	1a000009 	bne	ad98 <rtems_bdbuf_purge+0x138>                
    ad70:	ea000001 	b	ad7c <rtems_bdbuf_purge+0x11c>                  
    {                                                                 
      while (*prev != NULL && cur == (*prev)->avl.right)              
      {                                                               
        /* Up */                                                      
        cur = *prev;                                                  
        --prev;                                                       
    ad74:	e2455004 	sub	r5, r5, #4                                    <== NOT EXECUTED
    ad78:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
      *prev = cur;                                                    
      cur = cur->avl.right;                                           
    }                                                                 
    else                                                              
    {                                                                 
      while (*prev != NULL && cur == (*prev)->avl.right)              
    ad7c:	e5953000 	ldr	r3, [r5]                                      
    ad80:	e3530000 	cmp	r3, #0                                        
    ad84:	0a000003 	beq	ad98 <rtems_bdbuf_purge+0x138>                
    ad88:	e593200c 	ldr	r2, [r3, #12]                                 <== NOT EXECUTED
    ad8c:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
    ad90:	0afffff7 	beq	ad74 <rtems_bdbuf_purge+0x114>                <== NOT EXECUTED
    ad94:	ea000012 	b	ade4 <rtems_bdbuf_purge+0x184>                  <== NOT EXECUTED
    ad98:	e1a04003 	mov	r4, r3                                        
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
    ad9c:	e3540000 	cmp	r4, #0                                        
    ada0:	1affffc0 	bne	aca8 <rtems_bdbuf_purge+0x48>                 
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
    ada4:	e28d5088 	add	r5, sp, #136	; 0x88                           
    ada8:	ea000003 	b	adbc <rtems_bdbuf_purge+0x15c>                  
                                                                      
  while ((node = rtems_chain_get (purge_list)) != NULL)               
  {                                                                   
    rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;             
                                                                      
    if (bd->waiters == 0)                                             
    adac:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          
    adb0:	e3530000 	cmp	r3, #0                                        
    adb4:	03a04001 	moveq	r4, #1                                      
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_discard_buffer (bd);                                  
    adb8:	ebffff34 	bl	aa90 <rtems_bdbuf_discard_buffer>              
    adbc:	e1a00005 	mov	r0, r5                                        
    adc0:	ebfff012 	bl	6e10 <_Chain_Get>                              
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)              
{                                                                     
  bool wake_buffer_waiters = false;                                   
  rtems_chain_node *node = NULL;                                      
                                                                      
  while ((node = rtems_chain_get (purge_list)) != NULL)               
    adc4:	e2503000 	subs	r3, r0, #0                                   
    adc8:	1afffff7 	bne	adac <rtems_bdbuf_purge+0x14c>                
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_discard_buffer (bd);                                  
  }                                                                   
                                                                      
  if (wake_buffer_waiters)                                            
    adcc:	e3540000 	cmp	r4, #0                                        
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
    add0:	159f0020 	ldrne	r0, [pc, #32]	; adf8 <rtems_bdbuf_purge+0x198>
    add4:	1bfffbae 	blne	9c94 <rtems_bdbuf_wake>                      
                                                                      
  rtems_chain_initialize_empty (&purge_list);                         
  rtems_bdbuf_lock_cache ();                                          
  rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);           
  rtems_bdbuf_purge_list (&purge_list);                               
  rtems_bdbuf_unlock_cache ();                                        
    add8:	ebfffc20 	bl	9e60 <rtems_bdbuf_unlock_cache>                
}                                                                     
    addc:	e28dd094 	add	sp, sp, #148	; 0x94                           
    ade0:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
        cur = *prev;                                                  
        --prev;                                                       
      }                                                               
      if (*prev != NULL)                                              
        /* Right */                                                   
        cur = (*prev)->avl.right;                                     
    ade4:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
    ade8:	eaffffea 	b	ad98 <rtems_bdbuf_purge+0x138>                  <== NOT EXECUTED
                                                                      

00009c48 <rtems_bdbuf_purge_compare_major>: static bool rtems_bdbuf_purge_compare_major (dev_t a, dev_t b) { return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b); }
    9c48:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
    9c4c:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
    9c50:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
    9c54:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0000adfc <rtems_bdbuf_purge_major>: return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b); } void rtems_bdbuf_purge_major (rtems_device_major_number major) {
    adfc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  dev_t dev = rtems_filesystem_make_dev_t (major, 0);                 
                                                                      
  rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);           
    ae00:	e59f0004 	ldr	r0, [pc, #4]	; ae0c <rtems_bdbuf_purge_major+0x10><== NOT EXECUTED
    ae04:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    ae08:	eaffff94 	b	ac60 <rtems_bdbuf_purge>                        <== NOT EXECUTED
                                                                      

0000bc8c <rtems_bdbuf_read>: rtems_status_code rtems_bdbuf_read (dev_t dev, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
    bc8c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
    bc90:	e28db020 	add	fp, sp, #32                                   
  rtems_blkdev_request *req = NULL;                                   
  rtems_bdbuf_buffer   *bd = NULL;                                    
  rtems_blkdev_bnum     media_block = 0;                              
  size_t                bds_per_group = 0;                            
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bc94:	e24be028 	sub	lr, fp, #40	; 0x28                            
                                                                      
rtems_status_code                                                     
rtems_bdbuf_read (dev_t                dev,                           
                  rtems_blkdev_bnum    block,                         
                  rtems_bdbuf_buffer **bd_ptr)                        
{                                                                     
    bc98:	e24dd02c 	sub	sp, sp, #44	; 0x2c                            
  rtems_status_code     sc = RTEMS_SUCCESSFUL;                        
  rtems_disk_device    *dd = NULL;                                    
    bc9c:	e3a0c000 	mov	ip, #0                                        
                                                                      
rtems_status_code                                                     
rtems_bdbuf_read (dev_t                dev,                           
                  rtems_blkdev_bnum    block,                         
                  rtems_bdbuf_buffer **bd_ptr)                        
{                                                                     
    bca0:	e50b303c 	str	r3, [fp, #-60]	; 0x3c                         
  rtems_blkdev_request *req = NULL;                                   
  rtems_bdbuf_buffer   *bd = NULL;                                    
  rtems_blkdev_bnum     media_block = 0;                              
  size_t                bds_per_group = 0;                            
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bca4:	e58de000 	str	lr, [sp]                                      
    bca8:	e24b3024 	sub	r3, fp, #36	; 0x24                            
    bcac:	e24be02c 	sub	lr, fp, #44	; 0x2c                            
  rtems_status_code     sc = RTEMS_SUCCESSFUL;                        
  rtems_disk_device    *dd = NULL;                                    
  rtems_blkdev_request *req = NULL;                                   
  rtems_bdbuf_buffer   *bd = NULL;                                    
  rtems_blkdev_bnum     media_block = 0;                              
  size_t                bds_per_group = 0;                            
    bcb0:	e50bc02c 	str	ip, [fp, #-44]	; 0x2c                         
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bcb4:	e58de004 	str	lr, [sp, #4]                                  
rtems_bdbuf_read (dev_t                dev,                           
                  rtems_blkdev_bnum    block,                         
                  rtems_bdbuf_buffer **bd_ptr)                        
{                                                                     
  rtems_status_code     sc = RTEMS_SUCCESSFUL;                        
  rtems_disk_device    *dd = NULL;                                    
    bcb8:	e50bc024 	str	ip, [fp, #-36]	; 0x24                         
  rtems_blkdev_request *req = NULL;                                   
  rtems_bdbuf_buffer   *bd = NULL;                                    
  rtems_blkdev_bnum     media_block = 0;                              
    bcbc:	e50bc028 	str	ip, [fp, #-40]	; 0x28                         
  size_t                bds_per_group = 0;                            
                                                                      
  sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
    bcc0:	ebfff87a 	bl	9eb0 <rtems_bdbuf_obtain_disk>                 
  if (sc != RTEMS_SUCCESSFUL)                                         
    bcc4:	e3500000 	cmp	r0, #0                                        
    bcc8:	e50b0030 	str	r0, [fp, #-48]	; 0x30                         
    bccc:	1a0000a0 	bne	bf54 <rtems_bdbuf_read+0x2c8>                 
  /*                                                                  
   * TODO: This type of request structure is wrong and should be removed.
   */                                                                 
#define bdbuf_alloc(size) __builtin_alloca (size)                     
                                                                      
  req = bdbuf_alloc (sizeof (rtems_blkdev_request) +                  
    bcd0:	e59f329c 	ldr	r3, [pc, #668]	; bf74 <rtems_bdbuf_read+0x2e8>
    bcd4:	e5937000 	ldr	r7, [r3]                                      
    bcd8:	e2877001 	add	r7, r7, #1                                    
    bcdc:	e1a03207 	lsl	r3, r7, #4                                    
    bce0:	e283301c 	add	r3, r3, #28                                   
    bce4:	e04dd003 	sub	sp, sp, r3                                    
                                                                      
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",   
            media_block + dd->start, block, (unsigned) dev);          
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    bce8:	ebfff7e3 	bl	9c7c <rtems_bdbuf_lock_cache>                  
  rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
    bcec:	e51b5024 	ldr	r5, [fp, #-36]	; 0x24                         
                                 rtems_blkdev_request    *req,        
                                 rtems_bdbuf_buffer     **bd_ptr)     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block_end = dd->start + dd->size;         
  rtems_blkdev_bnum   media_block_count = dd->block_size / dd->media_block_size;
    bcf0:	e5952020 	ldr	r2, [r5, #32]                                 
    bcf4:	e5951024 	ldr	r1, [r5, #36]	; 0x24                          
    bcf8:	e1a00002 	mov	r0, r2                                        
    bcfc:	e50b2034 	str	r2, [fp, #-52]	; 0x34                         
    bd00:	eb0039b2 	bl	1a3d0 <__aeabi_uidiv>                          
  dev_t               dev = dd->dev;                                  
    bd04:	e285301c 	add	r3, r5, #28                                   
    bd08:	e8131008 	ldmda	r3, {r3, ip}                                
    bd0c:	e08cc003 	add	ip, ip, r3                                    
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",   
            media_block + dd->start, block, (unsigned) dev);          
                                                                      
  rtems_bdbuf_lock_cache ();                                          
  rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
    bd10:	e51b6028 	ldr	r6, [fp, #-40]	; 0x28                         
                                                                      
  if (media_block_end - media_block < transfer_count)                 
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->req_done = rtems_bdbuf_transfer_done;                          
    bd14:	e59f325c 	ldr	r3, [pc, #604]	; bf78 <rtems_bdbuf_read+0x2ec>
  uint32_t            transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
                                                                      
  if (media_block_end - media_block < transfer_count)                 
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
    bd18:	e51be030 	ldr	lr, [fp, #-48]	; 0x30                         
  /*                                                                  
   * TODO: This type of request structure is wrong and should be removed.
   */                                                                 
#define bdbuf_alloc(size) __builtin_alloca (size)                     
                                                                      
  req = bdbuf_alloc (sizeof (rtems_blkdev_request) +                  
    bd1c:	e28d4008 	add	r4, sp, #8                                    
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",   
            media_block + dd->start, block, (unsigned) dev);          
                                                                      
  rtems_bdbuf_lock_cache ();                                          
  rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
    bd20:	e51b202c 	ldr	r2, [fp, #-44]	; 0x2c                         
                                 rtems_bdbuf_buffer     **bd_ptr)     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block_end = dd->start + dd->size;         
  rtems_blkdev_bnum   media_block_count = dd->block_size / dd->media_block_size;
  dev_t               dev = dd->dev;                                  
    bd24:	e066c00c 	rsb	ip, r6, ip                                    
                                                                      
  if (media_block_end - media_block < transfer_count)                 
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->req_done = rtems_bdbuf_transfer_done;                          
    bd28:	e5843004 	str	r3, [r4, #4]                                  
  uint32_t            transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
                                                                      
  if (media_block_end - media_block < transfer_count)                 
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
    bd2c:	e584e000 	str	lr, [r4]                                      
  req->req_done = rtems_bdbuf_transfer_done;                          
  req->done_arg = req;                                                
    bd30:	e5844008 	str	r4, [r4, #8]                                  
                                 rtems_bdbuf_buffer     **bd_ptr)     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block_end = dd->start + dd->size;         
  rtems_blkdev_bnum   media_block_count = dd->block_size / dd->media_block_size;
  dev_t               dev = dd->dev;                                  
    bd34:	e595a000 	ldr	sl, [r5]                                      
    bd38:	e5958004 	ldr	r8, [r5, #4]                                  
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->req_done = rtems_bdbuf_transfer_done;                          
  req->done_arg = req;                                                
  req->io_task = rtems_task_self ();                                  
    bd3c:	e50bc044 	str	ip, [fp, #-68]	; 0x44                         
  if (rtems_bdbuf_tracer)                                             
    printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",   
            media_block + dd->start, block, (unsigned) dev);          
                                                                      
  rtems_bdbuf_lock_cache ();                                          
  rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
    bd40:	e50b2038 	str	r2, [fp, #-56]	; 0x38                         
                                 rtems_blkdev_request    *req,        
                                 rtems_bdbuf_buffer     **bd_ptr)     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block_end = dd->start + dd->size;         
  rtems_blkdev_bnum   media_block_count = dd->block_size / dd->media_block_size;
    bd44:	e50b0040 	str	r0, [fp, #-64]	; 0x40                         
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->req_done = rtems_bdbuf_transfer_done;                          
  req->done_arg = req;                                                
  req->io_task = rtems_task_self ();                                  
    bd48:	eb000a66 	bl	e6e8 <rtems_task_self>                         
  req->status = RTEMS_RESOURCE_IN_USE;                                
    bd4c:	e3a0e00c 	mov	lr, #12                                       
    bd50:	e584e00c 	str	lr, [r4, #12]                                 
  req->bufnum = 0;                                                    
    bd54:	e51be030 	ldr	lr, [fp, #-48]	; 0x30                         
    transfer_count = media_block_end - media_block;                   
                                                                      
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->req_done = rtems_bdbuf_transfer_done;                          
  req->done_arg = req;                                                
  req->io_task = rtems_task_self ();                                  
    bd58:	e5840014 	str	r0, [r4, #20]                                 
  req->status = RTEMS_RESOURCE_IN_USE;                                
  req->bufnum = 0;                                                    
                                                                      
  bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
    bd5c:	e1a02006 	mov	r2, r6                                        
    bd60:	e51b3038 	ldr	r3, [fp, #-56]	; 0x38                         
    bd64:	e1a0000a 	mov	r0, sl                                        
    bd68:	e1a01008 	mov	r1, r8                                        
  req->req = RTEMS_BLKDEV_REQ_READ;                                   
  req->req_done = rtems_bdbuf_transfer_done;                          
  req->done_arg = req;                                                
  req->io_task = rtems_task_self ();                                  
  req->status = RTEMS_RESOURCE_IN_USE;                                
  req->bufnum = 0;                                                    
    bd6c:	e584e010 	str	lr, [r4, #16]                                 
                                                                      
  bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
    bd70:	ebffff00 	bl	b978 <rtems_bdbuf_get_buffer_for_access>       
                                 rtems_bdbuf_buffer     **bd_ptr)     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block_end = dd->start + dd->size;         
  rtems_blkdev_bnum   media_block_count = dd->block_size / dd->media_block_size;
  dev_t               dev = dd->dev;                                  
    bd74:	e51bc044 	ldr	ip, [fp, #-68]	; 0x44                         
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  switch (bd->state)                                                  
    bd78:	e5909024 	ldr	r9, [r0, #36]	; 0x24                          
  *bd_ptr = bd;                                                       
                                                                      
  req->bufs [0].user   = bd;                                          
  req->bufs [0].block  = media_block;                                 
  req->bufs [0].length = block_size;                                  
  req->bufs [0].buffer = bd->buffer;                                  
    bd7c:	e5903020 	ldr	r3, [r0, #32]                                 
                                                                      
  *bd_ptr = bd;                                                       
                                                                      
  req->bufs [0].user   = bd;                                          
  req->bufs [0].block  = media_block;                                 
  req->bufs [0].length = block_size;                                  
    bd80:	e51b2034 	ldr	r2, [fp, #-52]	; 0x34                         
                                 rtems_bdbuf_buffer     **bd_ptr)     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
  rtems_blkdev_bnum   media_block_end = dd->start + dd->size;         
  rtems_blkdev_bnum   media_block_count = dd->block_size / dd->media_block_size;
  dev_t               dev = dd->dev;                                  
    bd84:	e15c0007 	cmp	ip, r7                                        
    bd88:	21a0c007 	movcs	ip, r7                                      
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  switch (bd->state)                                                  
    bd8c:	e3590002 	cmp	r9, #2                                        
  req->done_arg = req;                                                
  req->io_task = rtems_task_self ();                                  
  req->status = RTEMS_RESOURCE_IN_USE;                                
  req->bufnum = 0;                                                    
                                                                      
  bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
    bd90:	e1a05000 	mov	r5, r0                                        
  *bd_ptr = bd;                                                       
                                                                      
  req->bufs [0].user   = bd;                                          
  req->bufs [0].block  = media_block;                                 
  req->bufs [0].length = block_size;                                  
  req->bufs [0].buffer = bd->buffer;                                  
    bd94:	e5843020 	str	r3, [r4, #32]                                 
                                                                      
  bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
                                                                      
  *bd_ptr = bd;                                                       
                                                                      
  req->bufs [0].user   = bd;                                          
    bd98:	e5840024 	str	r0, [r4, #36]	; 0x24                          
  req->bufs [0].block  = media_block;                                 
    bd9c:	e5846018 	str	r6, [r4, #24]                                 
  req->bufs [0].length = block_size;                                  
    bda0:	e584201c 	str	r2, [r4, #28]                                 
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  switch (bd->state)                                                  
    bda4:	0a000046 	beq	bec4 <rtems_bdbuf_read+0x238>                 
    bda8:	e3590007 	cmp	r9, #7                                        
    bdac:	0a000044 	beq	bec4 <rtems_bdbuf_read+0x238>                 
    bdb0:	e3590001 	cmp	r9, #1                                        
    bdb4:	1a000006 	bne	bdd4 <rtems_bdbuf_read+0x148>                 
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    bdb8:	e1a07004 	mov	r7, r4                                        
    bdbc:	e3a03009 	mov	r3, #9                                        
    bdc0:	e1a0400c 	mov	r4, ip                                        
    bdc4:	e5803024 	str	r3, [r0, #36]	; 0x24                          
    bdc8:	e1a0c000 	mov	ip, r0                                        
    bdcc:	e1a05007 	mov	r5, r7                                        
    bdd0:	ea000036 	b	beb0 <rtems_bdbuf_read+0x224>                   
      return;                                                         
    case RTEMS_BDBUF_STATE_EMPTY:                                     
      rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);         
      break;                                                          
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
    bdd4:	e5900024 	ldr	r0, [r0, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    bdd8:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    bddc:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    bde0:	e380001d 	orr	r0, r0, #29                                   <== NOT EXECUTED
    bde4:	ea000056 	b	bf44 <rtems_bdbuf_read+0x2b8>                   <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  while (transfer_index < transfer_count)                             
  {                                                                   
    media_block += media_block_count;                                 
    bde8:	e51b3040 	ldr	r3, [fp, #-64]	; 0x40                         
static rtems_bdbuf_buffer *                                           
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,                    
                        dev_t                dev,                     
                        rtems_blkdev_bnum    block)                   
{                                                                     
  rtems_bdbuf_buffer* p = *root;                                      
    bdec:	e59fe188 	ldr	lr, [pc, #392]	; bf7c <rtems_bdbuf_read+0x2f0>
      break;                                                          
  }                                                                   
                                                                      
  while (transfer_index < transfer_count)                             
  {                                                                   
    media_block += media_block_count;                                 
    bdf0:	e0866003 	add	r6, r6, r3                                    
static rtems_bdbuf_buffer *                                           
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,                    
                        dev_t                dev,                     
                        rtems_blkdev_bnum    block)                   
{                                                                     
  rtems_bdbuf_buffer* p = *root;                                      
    bdf4:	e59e3040 	ldr	r3, [lr, #64]	; 0x40                          
    bdf8:	ea000009 	b	be24 <rtems_bdbuf_read+0x198>                   
                                                                      
  while ((p != NULL) && ((p->dev != dev) || (p->block != block)))     
  {                                                                   
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    bdfc:	e1580002 	cmp	r8, r2                                        <== NOT EXECUTED
    be00:	8a000004 	bhi	be18 <rtems_bdbuf_read+0x18c>                 <== NOT EXECUTED
    be04:	1a000005 	bne	be20 <rtems_bdbuf_read+0x194>                 <== NOT EXECUTED
    be08:	e15a0001 	cmp	sl, r1                                        <== NOT EXECUTED
    be0c:	8a000001 	bhi	be18 <rtems_bdbuf_read+0x18c>                 <== NOT EXECUTED
    be10:	ea000002 	b	be20 <rtems_bdbuf_read+0x194>                   <== NOT EXECUTED
    be14:	2a000001 	bcs	be20 <rtems_bdbuf_read+0x194>                 
    {                                                                 
      p = p->avl.right;                                               
    be18:	e593300c 	ldr	r3, [r3, #12]                                 
    be1c:	ea000000 	b	be24 <rtems_bdbuf_read+0x198>                   
    }                                                                 
    else                                                              
    {                                                                 
      p = p->avl.left;                                                
    be20:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
                        dev_t                dev,                     
                        rtems_blkdev_bnum    block)                   
{                                                                     
  rtems_bdbuf_buffer* p = *root;                                      
                                                                      
  while ((p != NULL) && ((p->dev != dev) || (p->block != block)))     
    be24:	e3530000 	cmp	r3, #0                                        
    be28:	0a000009 	beq	be54 <rtems_bdbuf_read+0x1c8>                 
    be2c:	e5931014 	ldr	r1, [r3, #20]                                 
    be30:	e151000a 	cmp	r1, sl                                        
    be34:	e5932018 	ldr	r2, [r3, #24]                                 
    be38:	1affffef 	bne	bdfc <rtems_bdbuf_read+0x170>                 
    be3c:	e1520008 	cmp	r2, r8                                        
    be40:	1affffed 	bne	bdfc <rtems_bdbuf_read+0x170>                 
    be44:	e593201c 	ldr	r2, [r3, #28]                                 
    be48:	e1520006 	cmp	r2, r6                                        
    be4c:	1afffff0 	bne	be14 <rtems_bdbuf_read+0x188>                 
    be50:	ea000018 	b	beb8 <rtems_bdbuf_read+0x22c>                   <== NOT EXECUTED
                                                                      
  bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);        
                                                                      
  if (bd == NULL)                                                     
  {                                                                   
    bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
    be54:	e1a0000a 	mov	r0, sl                                        
    be58:	e1a01008 	mov	r1, r8                                        
    be5c:	e1a02006 	mov	r2, r6                                        
    be60:	e51b3038 	ldr	r3, [fp, #-56]	; 0x38                         
    be64:	e50bc044 	str	ip, [fp, #-68]	; 0x44                         
    be68:	ebfffdd6 	bl	b5c8 <rtems_bdbuf_get_buffer_from_lru_list>    
                                                                      
    if (bd != NULL)                                                   
    be6c:	e3500000 	cmp	r0, #0                                        
                                                                      
  bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);        
                                                                      
  if (bd == NULL)                                                     
  {                                                                   
    bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
    be70:	e2877010 	add	r7, r7, #16                                   
                                                                      
    if (bd != NULL)                                                   
    be74:	e51bc044 	ldr	ip, [fp, #-68]	; 0x44                         
    be78:	0a00000e 	beq	beb8 <rtems_bdbuf_read+0x22c>                 
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
    be7c:	e590302c 	ldr	r3, [r0, #44]	; 0x2c                          <== NOT EXECUTED
    be80:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
    rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);           
                                                                      
    req->bufs [transfer_index].user   = bd;                           
    req->bufs [transfer_index].block  = media_block;                  
    req->bufs [transfer_index].length = block_size;                   
    req->bufs [transfer_index].buffer = bd->buffer;                   
    be84:	e5902020 	ldr	r2, [r0, #32]                                 <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
    be88:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
    be8c:	e583100c 	str	r1, [r3, #12]                                 <== NOT EXECUTED
                                                                      
    rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);           
                                                                      
    req->bufs [transfer_index].user   = bd;                           
    req->bufs [transfer_index].block  = media_block;                  
    req->bufs [transfer_index].length = block_size;                   
    be90:	e51b3034 	ldr	r3, [fp, #-52]	; 0x34                         <== NOT EXECUTED
    req->bufs [transfer_index].buffer = bd->buffer;                   
    be94:	e5872020 	str	r2, [r7, #32]                                 <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    be98:	e3a02009 	mov	r2, #9                                        <== NOT EXECUTED
    be9c:	e5802024 	str	r2, [r0, #36]	; 0x24                          <== NOT EXECUTED
    if (bd == NULL)                                                   
      break;                                                          
                                                                      
    rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);           
                                                                      
    req->bufs [transfer_index].user   = bd;                           
    bea0:	e5870024 	str	r0, [r7, #36]	; 0x24                          <== NOT EXECUTED
    req->bufs [transfer_index].block  = media_block;                  
    bea4:	e5876018 	str	r6, [r7, #24]                                 <== NOT EXECUTED
    req->bufs [transfer_index].length = block_size;                   
    bea8:	e587301c 	str	r3, [r7, #28]                                 <== NOT EXECUTED
    req->bufs [transfer_index].buffer = bd->buffer;                   
                                                                      
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("read-ahead", bd);                      
                                                                      
    ++transfer_index;                                                 
    beac:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
      break;                                                          
  }                                                                   
                                                                      
  while (transfer_index < transfer_count)                             
    beb0:	e1590004 	cmp	r9, r4                                        
    beb4:	3affffcb 	bcc	bde8 <rtems_bdbuf_read+0x15c>                 
    beb8:	e1a04005 	mov	r4, r5                                        
      rtems_bdbuf_show_users ("read-ahead", bd);                      
                                                                      
    ++transfer_index;                                                 
  }                                                                   
                                                                      
  req->bufnum = transfer_index;                                       
    bebc:	e5849010 	str	r9, [r4, #16]                                 
    bec0:	e1a0500c 	mov	r5, ip                                        
            media_block + dd->start, block, (unsigned) dev);          
                                                                      
  rtems_bdbuf_lock_cache ();                                          
  rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
                                                                      
  if (req->bufnum > 0)                                                
    bec4:	e5943010 	ldr	r3, [r4, #16]                                 
    bec8:	e3530000 	cmp	r3, #0                                        
    becc:	0a00000b 	beq	bf00 <rtems_bdbuf_read+0x274>                 
  {                                                                   
    sc = rtems_bdbuf_execute_transfer_request (dd, req, true);        
    bed0:	e1a01004 	mov	r1, r4                                        
    bed4:	e51b0024 	ldr	r0, [fp, #-36]	; 0x24                         
    bed8:	e3a02001 	mov	r2, #1                                        
    bedc:	ebfffbd0 	bl	ae24 <rtems_bdbuf_execute_transfer_request>    
    if (sc == RTEMS_SUCCESSFUL)                                       
    bee0:	e3500000 	cmp	r0, #0                                        
    bee4:	1a00001d 	bne	bf60 <rtems_bdbuf_read+0x2d4>                 
    bee8:	e1a00005 	mov	r0, r5                                        
    beec:	ebffebbe 	bl	6dec <_Chain_Extract>                          
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
    bef0:	e595302c 	ldr	r3, [r5, #44]	; 0x2c                          
    bef4:	e593200c 	ldr	r2, [r3, #12]                                 
    bef8:	e2822001 	add	r2, r2, #1                                    
    befc:	e583200c 	str	r2, [r3, #12]                                 
    }                                                                 
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL)                                         
  {                                                                   
    switch (bd->state)                                                
    bf00:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          
    bf04:	e3530002 	cmp	r3, #2                                        
    bf08:	0a000002 	beq	bf18 <rtems_bdbuf_read+0x28c>                 
    bf0c:	e3530007 	cmp	r3, #7                                        
    bf10:	1a000007 	bne	bf34 <rtems_bdbuf_read+0x2a8>                 
    bf14:	ea000001 	b	bf20 <rtems_bdbuf_read+0x294>                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    bf18:	e3a03003 	mov	r3, #3                                        
    bf1c:	ea000000 	b	bf24 <rtems_bdbuf_read+0x298>                   
    bf20:	e3a03004 	mov	r3, #4                                        
    {                                                                 
      rtems_bdbuf_show_users ("read", bd);                            
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
                                                                      
    *bd_ptr = bd;                                                     
    bf24:	e51be03c 	ldr	lr, [fp, #-60]	; 0x3c                         
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    bf28:	e5853024 	str	r3, [r5, #36]	; 0x24                          
    {                                                                 
      rtems_bdbuf_show_users ("read", bd);                            
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
                                                                      
    *bd_ptr = bd;                                                     
    bf2c:	e58e5000 	str	r5, [lr]                                      
    bf30:	ea000004 	b	bf48 <rtems_bdbuf_read+0x2bc>                   
        break;                                                        
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
    bf34:	e5950024 	ldr	r0, [r5, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    bf38:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    bf3c:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    bf40:	e3800002 	orr	r0, r0, #2                                    <== NOT EXECUTED
    bf44:	ebffea7c 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
    *bd_ptr = bd;                                                     
  }                                                                   
  else                                                                
    *bd_ptr = NULL;                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    bf48:	ebfff7c4 	bl	9e60 <rtems_bdbuf_unlock_cache>                
  rtems_bdbuf_release_disk (dd);                                      
    bf4c:	e51b0024 	ldr	r0, [fp, #-36]	; 0x24                         
    bf50:	ebfff813 	bl	9fa4 <rtems_bdbuf_release_disk>                
                                                                      
  return sc;                                                          
}                                                                     
    bf54:	e51b0030 	ldr	r0, [fp, #-48]	; 0x30                         
    bf58:	e24bd020 	sub	sp, fp, #32                                   
    bf5c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
    }                                                                 
                                                                      
    *bd_ptr = bd;                                                     
  }                                                                   
  else                                                                
    *bd_ptr = NULL;                                                   
    bf60:	e51b203c 	ldr	r2, [fp, #-60]	; 0x3c                         
    bf64:	e3a03000 	mov	r3, #0                                        
    bf68:	e5823000 	str	r3, [r2]                                      
    bf6c:	e50b0030 	str	r0, [fp, #-48]	; 0x30                         
    bf70:	eafffff4 	b	bf48 <rtems_bdbuf_read+0x2bc>                   
                                                                      

0000ab8c <rtems_bdbuf_release>: } static rtems_status_code rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind) { if (!bdbuf_cache.initialised)
    ab8c:	e59f30bc 	ldr	r3, [pc, #188]	; ac50 <rtems_bdbuf_release+0xc4>
    ab90:	e5d33088 	ldrb	r3, [r3, #136]	; 0x88                        
    ab94:	e3530000 	cmp	r3, #0                                        
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)                          
{                                                                     
    ab98:	e92d4010 	push	{r4, lr}                                     
    ab9c:	e1a04000 	mov	r4, r0                                        
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");           
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
    aba0:	03a00016 	moveq	r0, #22                                     
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (!bdbuf_cache.initialised)                                       
    aba4:	08bd8010 	popeq	{r4, pc}                                    
    return RTEMS_NOT_CONFIGURED;                                      
  if (bd == NULL)                                                     
    aba8:	e3540000 	cmp	r4, #0                                        
    abac:	03a00009 	moveq	r0, #9                                      
    abb0:	08bd8010 	popeq	{r4, pc}                                    
  if (rtems_bdbuf_tracer)                                             
  {                                                                   
    printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);              
    rtems_bdbuf_show_users (kind, bd);                                
  }                                                                   
  rtems_bdbuf_lock_cache();                                           
    abb4:	ebfffc30 	bl	9c7c <rtems_bdbuf_lock_cache>                  
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");           
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
    abb8:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
    abbc:	e2433003 	sub	r3, r3, #3                                    
    abc0:	e3530003 	cmp	r3, #3                                        
    abc4:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
    abc8:	ea000018 	b	ac30 <rtems_bdbuf_release+0xa4>                 <== NOT EXECUTED
    abcc:	0000abdc 	.word	0x0000abdc                                  <== NOT EXECUTED
    abd0:	0000ac24 	.word	0x0000ac24                                  <== NOT EXECUTED
    abd4:	0000ac18 	.word	0x0000ac18                                  <== NOT EXECUTED
    abd8:	0000ac18 	.word	0x0000ac18                                  <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
    abdc:	e594302c 	ldr	r3, [r4, #44]	; 0x2c                          
    abe0:	e593200c 	ldr	r2, [r3, #12]                                 
    abe4:	e2422001 	sub	r2, r2, #1                                    
    abe8:	e583200c 	str	r2, [r3, #12]                                 
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    abec:	e3a03002 	mov	r3, #2                                        
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
    abf0:	e59f005c 	ldr	r0, [pc, #92]	; ac54 <rtems_bdbuf_release+0xc8>
    abf4:	e5843024 	str	r3, [r4, #36]	; 0x24                          
    abf8:	e1a01004 	mov	r1, r4                                        
    abfc:	ebfff06f 	bl	6dc0 <_Chain_Append>                           
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)     
{                                                                     
  rtems_bdbuf_group_release (bd);                                     
  rtems_bdbuf_make_cached_and_add_to_lru_list (bd);                   
                                                                      
  if (bd->waiters)                                                    
    ac00:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
    ac04:	e3530000 	cmp	r3, #0                                        
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
    ac08:	159f0048 	ldrne	r0, [pc, #72]	; ac58 <rtems_bdbuf_release+0xcc>
  else                                                                
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
    ac0c:	059f0048 	ldreq	r0, [pc, #72]	; ac5c <rtems_bdbuf_release+0xd0>
    ac10:	ebfffc1f 	bl	9c94 <rtems_bdbuf_wake>                        
    ac14:	ea00000a 	b	ac44 <rtems_bdbuf_release+0xb8>                 
    case RTEMS_BDBUF_STATE_ACCESS_CACHED:                             
      rtems_bdbuf_add_to_lru_list_after_access (bd);                  
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                              
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
    ac18:	e1a00004 	mov	r0, r4                                        
    ac1c:	ebffffa9 	bl	aac8 <rtems_bdbuf_discard_buffer_after_access> 
      break;                                                          
    ac20:	ea000007 	b	ac44 <rtems_bdbuf_release+0xb8>                 
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);             
    ac24:	e1a00004 	mov	r0, r4                                        
    ac28:	ebfffcef 	bl	9fec <rtems_bdbuf_add_to_modified_list_after_access>
      break;                                                          
    ac2c:	ea000004 	b	ac44 <rtems_bdbuf_release+0xb8>                 
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
    ac30:	e5940024 	ldr	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    ac34:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    ac38:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    ac3c:	e380001c 	orr	r0, r0, #28                                   <== NOT EXECUTED
    ac40:	ebffef3d 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    ac44:	ebfffc85 	bl	9e60 <rtems_bdbuf_unlock_cache>                
    ac48:	e3a00000 	mov	r0, #0                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    ac4c:	e8bd8010 	pop	{r4, pc}                                      
                                                                      

00009fa4 <rtems_bdbuf_release_disk>: static void rtems_bdbuf_release_disk (rtems_disk_device *dd) {
    9fa4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc = rtems_disk_release (dd);                                       
    9fa8:	ebffe033 	bl	207c <rtems_disk_release>                      
  if (sc != RTEMS_SUCCESSFUL)                                         
    9fac:	e3500000 	cmp	r0, #0                                        
    9fb0:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);   
    9fb4:	e59f0000 	ldr	r0, [pc, #0]	; 9fbc <rtems_bdbuf_release_disk+0x18><== NOT EXECUTED
    9fb8:	ebfff25f 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

0000ab04 <rtems_bdbuf_release_modified>: } static rtems_status_code rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind) { if (!bdbuf_cache.initialised)
    ab04:	e59f307c 	ldr	r3, [pc, #124]	; ab88 <rtems_bdbuf_release_modified+0x84>
    ab08:	e5d33088 	ldrb	r3, [r3, #136]	; 0x88                        
    ab0c:	e3530000 	cmp	r3, #0                                        
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)                 
{                                                                     
    ab10:	e92d4010 	push	{r4, lr}                                     
    ab14:	e1a04000 	mov	r4, r0                                        
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");  
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
    ab18:	03a00016 	moveq	r0, #22                                     
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (!bdbuf_cache.initialised)                                       
    ab1c:	08bd8010 	popeq	{r4, pc}                                    
    return RTEMS_NOT_CONFIGURED;                                      
  if (bd == NULL)                                                     
    ab20:	e3540000 	cmp	r4, #0                                        
    ab24:	03a00009 	moveq	r0, #9                                      
    ab28:	08bd8010 	popeq	{r4, pc}                                    
  if (rtems_bdbuf_tracer)                                             
  {                                                                   
    printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);              
    rtems_bdbuf_show_users (kind, bd);                                
  }                                                                   
  rtems_bdbuf_lock_cache();                                           
    ab2c:	ebfffc52 	bl	9c7c <rtems_bdbuf_lock_cache>                  
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");  
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
    ab30:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
    ab34:	e3530003 	cmp	r3, #3                                        
    ab38:	3a00000a 	bcc	ab68 <rtems_bdbuf_release_modified+0x64>      
    ab3c:	e3530005 	cmp	r3, #5                                        
    ab40:	9a000002 	bls	ab50 <rtems_bdbuf_release_modified+0x4c>      
    ab44:	e3530006 	cmp	r3, #6                                        
    ab48:	1a000006 	bne	ab68 <rtems_bdbuf_release_modified+0x64>      
    ab4c:	ea000002 	b	ab5c <rtems_bdbuf_release_modified+0x58>        
  {                                                                   
    case RTEMS_BDBUF_STATE_ACCESS_CACHED:                             
    case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                              
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);             
    ab50:	e1a00004 	mov	r0, r4                                        
    ab54:	ebfffd24 	bl	9fec <rtems_bdbuf_add_to_modified_list_after_access>
      break;                                                          
    ab58:	ea000007 	b	ab7c <rtems_bdbuf_release_modified+0x78>        
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
    ab5c:	e1a00004 	mov	r0, r4                                        
    ab60:	ebffffd8 	bl	aac8 <rtems_bdbuf_discard_buffer_after_access> 
      break;                                                          
    ab64:	ea000004 	b	ab7c <rtems_bdbuf_release_modified+0x78>        
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
    ab68:	e5940024 	ldr	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    ab6c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    ab70:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    ab74:	e3800004 	orr	r0, r0, #4                                    <== NOT EXECUTED
    ab78:	ebffef6f 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    ab7c:	ebfffcb7 	bl	9e60 <rtems_bdbuf_unlock_cache>                
    ab80:	e3a00000 	mov	r0, #0                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    ab84:	e8bd8010 	pop	{r4, pc}                                      
                                                                      

0000a6fc <rtems_bdbuf_remove_from_tree>: return bdbuf_cache.buffer_waiters.count; } static void rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd) {
    a6fc:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
                       const rtems_bdbuf_buffer* node)                
{                                                                     
  dev_t             dev = node->dev;                                  
  rtems_blkdev_bnum block = node->block;                              
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
    a700:	e59f3340 	ldr	r3, [pc, #832]	; aa48 <rtems_bdbuf_remove_from_tree+0x34c>
  return bdbuf_cache.buffer_waiters.count;                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)                 
{                                                                     
    a704:	e24dd080 	sub	sp, sp, #128	; 0x80                           
    a708:	e1a05000 	mov	r5, r0                                        
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
    a70c:	e3a01000 	mov	r1, #0                                        
    a710:	e1a0000d 	mov	r0, sp                                        
    a714:	e3a02080 	mov	r2, #128	; 0x80                               
                       const rtems_bdbuf_buffer* node)                
{                                                                     
  dev_t             dev = node->dev;                                  
  rtems_blkdev_bnum block = node->block;                              
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
    a718:	e5934040 	ldr	r4, [r3, #64]	; 0x40                          
 */                                                                   
static int                                                            
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer**      root,                
                       const rtems_bdbuf_buffer* node)                
{                                                                     
  dev_t             dev = node->dev;                                  
    a71c:	e5958014 	ldr	r8, [r5, #20]                                 
    a720:	e2857018 	add	r7, r5, #24                                   
    a724:	e8970480 	ldm	r7, {r7, sl}                                  
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
    a728:	e1a0600d 	mov	r6, sp                                        
    a72c:	eb001c51 	bl	11878 <memset>                                 
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    {                                                                 
      p->avl.cache = 1;                                               
    a730:	e3a00001 	mov	r0, #1                                        
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dev != dev) || (p->block != block))                  
    {                                                                 
      p->avl.cache = -1;                                              
    a734:	e3e01000 	mvn	r1, #0                                        
    a738:	ea000014 	b	a790 <rtems_bdbuf_remove_from_tree+0x94>        
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    a73c:	e5943018 	ldr	r3, [r4, #24]                                 
    a740:	e1570003 	cmp	r7, r3                                        
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
    a744:	e4864004 	str	r4, [r6], #4                                  
                                                                      
    if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))    
    a748:	e5942014 	ldr	r2, [r4, #20]                                 
    a74c:	8a000009 	bhi	a778 <rtems_bdbuf_remove_from_tree+0x7c>      
    a750:	1a000001 	bne	a75c <rtems_bdbuf_remove_from_tree+0x60>      
    a754:	e1580002 	cmp	r8, r2                                        
    a758:	8a000006 	bhi	a778 <rtems_bdbuf_remove_from_tree+0x7c>      
    a75c:	e1520008 	cmp	r2, r8                                        
    a760:	1a000008 	bne	a788 <rtems_bdbuf_remove_from_tree+0x8c>      
    a764:	e1530007 	cmp	r3, r7                                        
    a768:	1a000006 	bne	a788 <rtems_bdbuf_remove_from_tree+0x8c>      
    a76c:	e594301c 	ldr	r3, [r4, #28]                                 
    a770:	e153000a 	cmp	r3, sl                                        
    a774:	2a000002 	bcs	a784 <rtems_bdbuf_remove_from_tree+0x88>      
    {                                                                 
      p->avl.cache = 1;                                               
    a778:	e5c40010 	strb	r0, [r4, #16]                                
      p = p->avl.right;                                               
    a77c:	e594400c 	ldr	r4, [r4, #12]                                 
    a780:	ea000002 	b	a790 <rtems_bdbuf_remove_from_tree+0x94>        
    }                                                                 
    else if ((p->dev != dev) || (p->block != block))                  
    a784:	0a000004 	beq	a79c <rtems_bdbuf_remove_from_tree+0xa0>      
    {                                                                 
      p->avl.cache = -1;                                              
    a788:	e5c41010 	strb	r1, [r4, #16]                                
      p = p->avl.left;                                                
    a78c:	e5944008 	ldr	r4, [r4, #8]                                  
                                                                      
  bool modified = false;                                              
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
    a790:	e3540000 	cmp	r4, #0                                        
    a794:	1affffe8 	bne	a73c <rtems_bdbuf_remove_from_tree+0x40>      
    a798:	ea0000a3 	b	aa2c <rtems_bdbuf_remove_from_tree+0x330>       <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  q = p;                                                              
                                                                      
  buf_prev--;                                                         
    a79c:	e2462004 	sub	r2, r6, #4                                    
  if (buf_prev > buf_stack)                                           
    a7a0:	e1a0300d 	mov	r3, sp                                        
    a7a4:	e1520003 	cmp	r2, r3                                        
  {                                                                   
    p = NULL;                                                         
  }                                                                   
                                                                      
  /* at this moment q - is a node to delete, p is q's parent */       
  if (q->avl.right == NULL)                                           
    a7a8:	e594300c 	ldr	r3, [r4, #12]                                 
  }                                                                   
                                                                      
  q = p;                                                              
                                                                      
  buf_prev--;                                                         
  if (buf_prev > buf_stack)                                           
    a7ac:	93a01000 	movls	r1, #0                                      
  {                                                                   
    p = *(buf_prev - 1);                                              
    a7b0:	85121004 	ldrhi	r1, [r2, #-4]                               
  {                                                                   
    p = NULL;                                                         
  }                                                                   
                                                                      
  /* at this moment q - is a node to delete, p is q's parent */       
  if (q->avl.right == NULL)                                           
    a7b4:	e3530000 	cmp	r3, #0                                        
    a7b8:	1a000005 	bne	a7d4 <rtems_bdbuf_remove_from_tree+0xd8>      
  {                                                                   
    r = q->avl.left;                                                  
    a7bc:	e5943008 	ldr	r3, [r4, #8]                                  
    if (r != NULL)                                                    
    a7c0:	e3530000 	cmp	r3, #0                                        
    {                                                                 
      r->avl.bal = 0;                                                 
    a7c4:	13a00000 	movne	r0, #0                                      
    a7c8:	15c30011 	strbne	r0, [r3, #17]                              
    a7cc:	e1a06002 	mov	r6, r2                                        
    a7d0:	ea00001e 	b	a850 <rtems_bdbuf_remove_from_tree+0x154>       
  {                                                                   
    rtems_bdbuf_buffer **t;                                           
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    a7d4:	e5930008 	ldr	r0, [r3, #8]                                  
    a7d8:	e3500000 	cmp	r0, #0                                        
    {                                                                 
      r->avl.left = q->avl.left;                                      
    a7dc:	0594c008 	ldreq	ip, [r4, #8]                                
  {                                                                   
    rtems_bdbuf_buffer **t;                                           
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    a7e0:	11a00006 	movne	r0, r6                                      
    a7e4:	11a0c003 	movne	ip, r3                                      
                                                                      
      while (s->avl.left != NULL)                                     
      {                                                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
    a7e8:	13e05000 	mvnne	r5, #0                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
      r->avl.bal = q->avl.bal;                                        
    a7ec:	05d40011 	ldrbeq	r0, [r4, #17]                              
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
    a7f0:	0583c008 	streq	ip, [r3, #8]                                
  {                                                                   
    rtems_bdbuf_buffer **t;                                           
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    a7f4:	1a000005 	bne	a810 <rtems_bdbuf_remove_from_tree+0x114>     
    a7f8:	ea000010 	b	a840 <rtems_bdbuf_remove_from_tree+0x144>       
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
      {                                                               
        *buf_prev++ = r = s;                                          
    a7fc:	e5003004 	str	r3, [r0, #-4]                                 <== NOT EXECUTED
        s = r->avl.left;                                              
    a800:	e5936008 	ldr	r6, [r3, #8]                                  <== NOT EXECUTED
        r->avl.cache = -1;                                            
    a804:	e5c35010 	strb	r5, [r3, #16]                                <== NOT EXECUTED
    a808:	e1a0c003 	mov	ip, r3                                        <== NOT EXECUTED
    a80c:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
    a810:	e5936008 	ldr	r6, [r3, #8]                                  <== NOT EXECUTED
    a814:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
      {                                                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
    a818:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    a81c:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
    a820:	1afffff5 	bne	a7fc <rtems_bdbuf_remove_from_tree+0x100>     <== NOT EXECUTED
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
    a824:	e5947008 	ldr	r7, [r4, #8]                                  <== NOT EXECUTED
      r->avl.left = s->avl.right;                                     
    a828:	e593500c 	ldr	r5, [r3, #12]                                 <== NOT EXECUTED
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
    a82c:	e5d40011 	ldrb	r0, [r4, #17]                                <== NOT EXECUTED
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
      r->avl.left = s->avl.right;                                     
      s->avl.right = q->avl.right;                                    
    a830:	e594400c 	ldr	r4, [r4, #12]                                 <== NOT EXECUTED
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
    a834:	e5837008 	str	r7, [r3, #8]                                  <== NOT EXECUTED
      r->avl.left = s->avl.right;                                     
      s->avl.right = q->avl.right;                                    
    a838:	e583400c 	str	r4, [r3, #12]                                 <== NOT EXECUTED
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
      r->avl.left = s->avl.right;                                     
    a83c:	e58c5008 	str	r5, [ip, #8]                                  <== NOT EXECUTED
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
    a840:	e5c30011 	strb	r0, [r3, #17]                                
      s->avl.cache = 1;                                               
    a844:	e3a00001 	mov	r0, #1                                        
    a848:	e5c30010 	strb	r0, [r3, #16]                                
                                                                      
      *t = q = s;                                                     
    a84c:	e5823000 	str	r3, [r2]                                      
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
    a850:	e3510000 	cmp	r1, #0                                        
      p->avl.right = q;                                               
    }                                                                 
  }                                                                   
  else                                                                
  {                                                                   
    *root = q;                                                        
    a854:	059f21ec 	ldreq	r2, [pc, #492]	; aa48 <rtems_bdbuf_remove_from_tree+0x34c>
    a858:	05823040 	streq	r3, [r2, #64]	; 0x40                        
                                                                      
      *t = q = s;                                                     
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
    a85c:	0a000003 	beq	a870 <rtems_bdbuf_remove_from_tree+0x174>     
  {                                                                   
    if (p->avl.cache == -1)                                           
    a860:	e1d121d0 	ldrsb	r2, [r1, #16]                               
    a864:	e3720001 	cmn	r2, #1                                        
    {                                                                 
      p->avl.left = q;                                                
    a868:	05813008 	streq	r3, [r1, #8]                                
    }                                                                 
    else                                                              
    {                                                                 
      p->avl.right = q;                                               
    a86c:	1581300c 	strne	r3, [r1, #12]                               
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
    a870:	e1a0700d 	mov	r7, sp                                        
    a874:	e1560007 	cmp	r6, r7                                        
    a878:	9a000070 	bls	aa40 <rtems_bdbuf_remove_from_tree+0x344>     
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
    a87c:	e1a0700d 	mov	r7, sp                                        
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
        case  0:                                                      
          p->avl.bal = 1;                                             
    a880:	e3a04001 	mov	r4, #1                                        
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
    a884:	e3a01000 	mov	r1, #0                                        
        case +1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
                                                                      
        case  0:                                                      
          p->avl.bal = -1;                                            
    a888:	e3e05000 	mvn	r5, #0                                        
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
    {                                                                 
      p = *--buf_prev;                                                
    a88c:	e5363004 	ldr	r3, [r6, #-4]!                                
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
    a890:	e1d3a1d0 	ldrsb	sl, [r3, #16]                               
    a894:	e37a0001 	cmn	sl, #1                                        
    a898:	e1d3c1d1 	ldrsb	ip, [r3, #17]                               
    a89c:	1a000027 	bne	a940 <rtems_bdbuf_remove_from_tree+0x244>     
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
    a8a0:	e35c0000 	cmp	ip, #0                                        
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
        case  0:                                                      
          p->avl.bal = 1;                                             
    a8a4:	05c34011 	strbeq	r4, [r3, #17]                              
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
    a8a8:	0a00002d 	beq	a964 <rtems_bdbuf_remove_from_tree+0x268>     
    a8ac:	e35c0001 	cmp	ip, #1                                        
    a8b0:	0a000002 	beq	a8c0 <rtems_bdbuf_remove_from_tree+0x1c4>     
    a8b4:	e37c0001 	cmn	ip, #1                                        
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
    a8b8:	05c31011 	strbeq	r1, [r3, #17]                              
    a8bc:	ea00004b 	b	a9f0 <rtems_bdbuf_remove_from_tree+0x2f4>       
          p->avl.bal = 1;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case +1:                                                      
          p1 = p->avl.right;                                          
    a8c0:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
                                                                      
          if (p1->avl.bal >= 0) /* simple RR-turn */                  
    a8c4:	e1d091d1 	ldrsb	r9, [r0, #17]                               <== NOT EXECUTED
    a8c8:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
    a8cc:	e5908008 	ldr	r8, [r0, #8]                                  <== NOT EXECUTED
    a8d0:	ba000009 	blt	a8fc <rtems_bdbuf_remove_from_tree+0x200>     <== NOT EXECUTED
          {                                                           
            p->avl.right = p1->avl.left;                              
    a8d4:	e583800c 	str	r8, [r3, #12]                                 <== NOT EXECUTED
            p1->avl.left = p;                                         
    a8d8:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
              p1->avl.bal = -1;                                       
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
    a8dc:	15c31011 	strbne	r1, [r3, #17]                              <== NOT EXECUTED
            p->avl.right = p1->avl.left;                              
            p1->avl.left = p;                                         
                                                                      
            if (p1->avl.bal == 0)                                     
            {                                                         
              p1->avl.bal = -1;                                       
    a8e0:	05c0a011 	strbeq	sl, [r0, #17]                              <== NOT EXECUTED
    a8e4:	01a02000 	moveq	r2, r0                                      <== NOT EXECUTED
    a8e8:	01a03009 	moveq	r3, r9                                      <== NOT EXECUTED
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
              p1->avl.bal = 0;                                        
    a8ec:	11a02000 	movne	r2, r0                                      <== NOT EXECUTED
    a8f0:	15c01011 	strbne	r1, [r0, #17]                              <== NOT EXECUTED
          if (p1->avl.bal >= 0) /* simple RR-turn */                  
          {                                                           
            p->avl.right = p1->avl.left;                              
            p1->avl.left = p;                                         
                                                                      
            if (p1->avl.bal == 0)                                     
    a8f4:	1a00001b 	bne	a968 <rtems_bdbuf_remove_from_tree+0x26c>     <== NOT EXECUTED
    a8f8:	ea00003e 	b	a9f8 <rtems_bdbuf_remove_from_tree+0x2fc>       <== NOT EXECUTED
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
    a8fc:	e598200c 	ldr	r2, [r8, #12]                                 <== NOT EXECUTED
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
    a900:	e1d8c1d1 	ldrsb	ip, [r8, #17]                               <== NOT EXECUTED
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
    a904:	e5802008 	str	r2, [r0, #8]                                  <== NOT EXECUTED
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
    a908:	e35c0001 	cmp	ip, #1                                        <== NOT EXECUTED
    a90c:	05c3a011 	strbeq	sl, [r3, #17]                              <== NOT EXECUTED
    a910:	15c31011 	strbne	r1, [r3, #17]                              <== NOT EXECUTED
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
    a914:	e5982008 	ldr	r2, [r8, #8]                                  <== NOT EXECUTED
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
    a918:	e588000c 	str	r0, [r8, #12]                                 <== NOT EXECUTED
            p->avl.right = p2->avl.left;                              
            p2->avl.left = p;                                         
    a91c:	e5883008 	str	r3, [r8, #8]                                  <== NOT EXECUTED
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
    a920:	e583200c 	str	r2, [r3, #12]                                 <== NOT EXECUTED
            p2->avl.left = p;                                         
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
    a924:	e1d831d1 	ldrsb	r3, [r8, #17]                               <== NOT EXECUTED
    a928:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
    a92c:	05c04011 	strbeq	r4, [r0, #17]                              <== NOT EXECUTED
    a930:	15c01011 	strbne	r1, [r0, #17]                              <== NOT EXECUTED
            }                                                         
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
    a934:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
    a938:	e5c81011 	strb	r1, [r8, #17]                                <== NOT EXECUTED
    a93c:	ea00002c 	b	a9f4 <rtems_bdbuf_remove_from_tree+0x2f8>       <== NOT EXECUTED
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
    a940:	e35c0000 	cmp	ip, #0                                        
        case +1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
                                                                      
        case  0:                                                      
          p->avl.bal = -1;                                            
    a944:	05c35011 	strbeq	r5, [r3, #17]                              
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
    a948:	0a000005 	beq	a964 <rtems_bdbuf_remove_from_tree+0x268>     
    a94c:	e35c0001 	cmp	ip, #1                                        
    a950:	0a000002 	beq	a960 <rtems_bdbuf_remove_from_tree+0x264>     
    a954:	e37c0001 	cmn	ip, #1                                        <== NOT EXECUTED
    a958:	1a000024 	bne	a9f0 <rtems_bdbuf_remove_from_tree+0x2f4>     <== NOT EXECUTED
    a95c:	ea000003 	b	a970 <rtems_bdbuf_remove_from_tree+0x274>       <== NOT EXECUTED
      {                                                               
        case +1:                                                      
          p->avl.bal = 0;                                             
    a960:	e5c31011 	strb	r1, [r3, #17]                                
          break;                                                      
                                                                      
        case  0:                                                      
          p->avl.bal = -1;                                            
    a964:	e1a02003 	mov	r2, r3                                        
    a968:	e1a0300c 	mov	r3, ip                                        
    a96c:	ea000021 	b	a9f8 <rtems_bdbuf_remove_from_tree+0x2fc>       
          modified = false;                                           
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
    a970:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
                                                                      
          if (p1->avl.bal <= 0) /* simple LL-turn */                  
    a974:	e1d081d1 	ldrsb	r8, [r0, #17]                               <== NOT EXECUTED
    a978:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
    a97c:	e590c00c 	ldr	ip, [r0, #12]                                 <== NOT EXECUTED
    a980:	ca000009 	bgt	a9ac <rtems_bdbuf_remove_from_tree+0x2b0>     <== NOT EXECUTED
          {                                                           
            p->avl.left = p1->avl.right;                              
    a984:	e583c008 	str	ip, [r3, #8]                                  <== NOT EXECUTED
            p1->avl.right = p;                                        
    a988:	e580300c 	str	r3, [r0, #12]                                 <== NOT EXECUTED
              p1->avl.bal = 1;                                        
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
    a98c:	15c31011 	strbne	r1, [r3, #17]                              <== NOT EXECUTED
          {                                                           
            p->avl.left = p1->avl.right;                              
            p1->avl.right = p;                                        
            if (p1->avl.bal == 0)                                     
            {                                                         
              p1->avl.bal = 1;                                        
    a990:	05c04011 	strbeq	r4, [r0, #17]                              <== NOT EXECUTED
    a994:	01a02000 	moveq	r2, r0                                      <== NOT EXECUTED
    a998:	01a03008 	moveq	r3, r8                                      <== NOT EXECUTED
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
              p1->avl.bal = 0;                                        
    a99c:	11a02000 	movne	r2, r0                                      <== NOT EXECUTED
    a9a0:	15c01011 	strbne	r1, [r0, #17]                              <== NOT EXECUTED
                                                                      
          if (p1->avl.bal <= 0) /* simple LL-turn */                  
          {                                                           
            p->avl.left = p1->avl.right;                              
            p1->avl.right = p;                                        
            if (p1->avl.bal == 0)                                     
    a9a4:	1a000012 	bne	a9f4 <rtems_bdbuf_remove_from_tree+0x2f8>     <== NOT EXECUTED
    a9a8:	ea000012 	b	a9f8 <rtems_bdbuf_remove_from_tree+0x2fc>       <== NOT EXECUTED
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
    a9ac:	e59c2008 	ldr	r2, [ip, #8]                                  <== NOT EXECUTED
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
            p2->avl.right = p;                                        
                                                                      
            if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
    a9b0:	e1dc81d1 	ldrsb	r8, [ip, #17]                               <== NOT EXECUTED
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
    a9b4:	e580200c 	str	r2, [r0, #12]                                 <== NOT EXECUTED
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
            p2->avl.right = p;                                        
                                                                      
            if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
    a9b8:	e3780001 	cmn	r8, #1                                        <== NOT EXECUTED
    a9bc:	05c34011 	strbeq	r4, [r3, #17]                              <== NOT EXECUTED
    a9c0:	15c31011 	strbne	r1, [r3, #17]                              <== NOT EXECUTED
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
    a9c4:	e59c200c 	ldr	r2, [ip, #12]                                 <== NOT EXECUTED
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
    a9c8:	e58c0008 	str	r0, [ip, #8]                                  <== NOT EXECUTED
            p->avl.left = p2->avl.right;                              
            p2->avl.right = p;                                        
    a9cc:	e58c300c 	str	r3, [ip, #12]                                 <== NOT EXECUTED
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
    a9d0:	e5832008 	str	r2, [r3, #8]                                  <== NOT EXECUTED
            p2->avl.right = p;                                        
                                                                      
            if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
    a9d4:	e1dc31d1 	ldrsb	r3, [ip, #17]                               <== NOT EXECUTED
    a9d8:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
    a9dc:	05c05011 	strbeq	r5, [r0, #17]                              <== NOT EXECUTED
    a9e0:	15c01011 	strbne	r1, [r0, #17]                              <== NOT EXECUTED
            }                                                         
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
    a9e4:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
                                                                      
            if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
    a9e8:	e5cc1011 	strb	r1, [ip, #17]                                <== NOT EXECUTED
    a9ec:	ea000000 	b	a9f4 <rtems_bdbuf_remove_from_tree+0x2f8>       <== NOT EXECUTED
    a9f0:	e1a02003 	mov	r2, r3                                        
    a9f4:	e3a03001 	mov	r3, #1                                        
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
    a9f8:	e1560007 	cmp	r6, r7                                        
    a9fc:	9a000007 	bls	aa20 <rtems_bdbuf_remove_from_tree+0x324>     
    {                                                                 
      q = *(buf_prev - 1);                                            
    aa00:	e5160004 	ldr	r0, [r6, #-4]                                 <== NOT EXECUTED
                                                                      
      if (q->avl.cache == -1)                                         
    aa04:	e1d0c1d0 	ldrsb	ip, [r0, #16]                               <== NOT EXECUTED
    aa08:	e37c0001 	cmn	ip, #1                                        <== NOT EXECUTED
      {                                                               
        q->avl.left = p;                                              
    aa0c:	05802008 	streq	r2, [r0, #8]                                <== NOT EXECUTED
      }                                                               
      else                                                            
      {                                                               
        q->avl.right = p;                                             
    aa10:	1580200c 	strne	r2, [r0, #12]                               <== NOT EXECUTED
    *root = q;                                                        
  }                                                                   
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
    aa14:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    aa18:	1affff9b 	bne	a88c <rtems_bdbuf_remove_from_tree+0x190>     <== NOT EXECUTED
    aa1c:	ea000007 	b	aa40 <rtems_bdbuf_remove_from_tree+0x344>       <== NOT EXECUTED
        q->avl.right = p;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
    aa20:	e59f3020 	ldr	r3, [pc, #32]	; aa48 <rtems_bdbuf_remove_from_tree+0x34c>
    aa24:	e5832040 	str	r2, [r3, #64]	; 0x40                          
    aa28:	ea000004 	b	aa40 <rtems_bdbuf_remove_from_tree+0x344>       
                                                                      
static void                                                           
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)                 
{                                                                     
  if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)            
    rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);  
    aa2c:	e5950024 	ldr	r0, [r5, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    aa30:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    aa34:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    aa38:	e3800009 	orr	r0, r0, #9                                    <== NOT EXECUTED
    aa3c:	ebffefbe 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
static void                                                           
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)                 
{                                                                     
  if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)            
    rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);  
}                                                                     
    aa40:	e28dd080 	add	sp, sp, #128	; 0x80                           
    aa44:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
                                                                      

0000aa4c <rtems_bdbuf_remove_from_tree_and_lru_list>: static void rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd) { switch (bd->state)
    aa4c:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          
    aa50:	e3530000 	cmp	r3, #0                                        
    rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);  
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)    
{                                                                     
    aa54:	e92d4010 	push	{r4, lr}                                     
    aa58:	e1a04000 	mov	r4, r0                                        
  switch (bd->state)                                                  
    aa5c:	0a000008 	beq	aa84 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
    aa60:	e3530002 	cmp	r3, #2                                        
    aa64:	1a000001 	bne	aa70 <rtems_bdbuf_remove_from_tree_and_lru_list+0x24>
  {                                                                   
    case RTEMS_BDBUF_STATE_FREE:                                      
      break;                                                          
    case RTEMS_BDBUF_STATE_CACHED:                                    
      rtems_bdbuf_remove_from_tree (bd);                              
    aa68:	ebffff23 	bl	a6fc <rtems_bdbuf_remove_from_tree>            
      break;                                                          
    aa6c:	ea000004 	b	aa84 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
    aa70:	e5900024 	ldr	r0, [r0, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    aa74:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    aa78:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    aa7c:	e3800008 	orr	r0, r0, #8                                    <== NOT EXECUTED
    aa80:	ebffefad 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
    aa84:	e1a00004 	mov	r0, r4                                        
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
  }                                                                   
                                                                      
  rtems_chain_extract (&bd->link);                                    
}                                                                     
    aa88:	e8bd4010 	pop	{r4, lr}                                      
    aa8c:	eafff0d6 	b	6dec <_Chain_Extract>                           
                                                                      

0000b0a4 <rtems_bdbuf_swapout_task>: * not this. * @return rtems_task Not used. */ static rtems_task rtems_bdbuf_swapout_task (rtems_task_argument arg) {
    b0a4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  rtems_bdbuf_swapout_transfer transfer;                              
  uint32_t                     period_in_ticks;                       
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;;
    b0a8:	e59f42f8 	ldr	r4, [pc, #760]	; b3a8 <rtems_bdbuf_swapout_task+0x304>
    b0ac:	e594200c 	ldr	r2, [r4, #12]                                 
 *            not this.                                               
 * @return rtems_task Not used.                                       
 */                                                                   
static rtems_task                                                     
rtems_bdbuf_swapout_task (rtems_task_argument arg)                    
{                                                                     
    b0b0:	e24dd034 	sub	sp, sp, #52	; 0x34                            
  rtems_bdbuf_swapout_transfer transfer;                              
  uint32_t                     period_in_ticks;                       
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;;
    b0b4:	e58d2008 	str	r2, [sp, #8]                                  
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
    b0b8:	ebfffd7b 	bl	a6ac <rtems_bdbuf_swapout_writereq_alloc>      
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
    b0bc:	e59dc008 	ldr	ip, [sp, #8]                                  
    b0c0:	e59f22e4 	ldr	r2, [pc, #740]	; b3ac <rtems_bdbuf_swapout_task+0x308>
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    b0c4:	e28d3010 	add	r3, sp, #16                                   
  rtems_bdbuf_swapout_transfer transfer;                              
  uint32_t                     period_in_ticks;                       
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;;
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
    b0c8:	e58d0028 	str	r0, [sp, #40]	; 0x28                          
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
    b0cc:	e3a00ffa 	mov	r0, #1000	; 0x3e8                             
    b0d0:	e592100c 	ldr	r1, [r2, #12]                                 
  the_chain->permanent_null = NULL;                                   
    b0d4:	e3a05000 	mov	r5, #0                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    b0d8:	e2832004 	add	r2, r3, #4                                    
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;;
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
  rtems_chain_initialize_empty (&transfer.bds);                       
  transfer.dev = BDBUF_INVALID_DEV;                                   
    b0dc:	e3e0a000 	mvn	sl, #0                                        
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
    b0e0:	e000009c 	mul	r0, ip, r0                                    
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;;
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
  rtems_chain_initialize_empty (&transfer.bds);                       
  transfer.dev = BDBUF_INVALID_DEV;                                   
    b0e4:	e3e09000 	mvn	r9, #0                                        
    b0e8:	e58d2010 	str	r2, [sp, #16]                                 
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    b0ec:	e58d3018 	str	r3, [sp, #24]                                 
    b0f0:	e58d901c 	str	r9, [sp, #28]                                 
    b0f4:	e58da020 	str	sl, [sp, #32]                                 
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
    b0f8:	e58d5014 	str	r5, [sp, #20]                                 
  transfer.syncing = false;                                           
    b0fc:	e5cd5024 	strb	r5, [sp, #36]	; 0x24                         
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
    b100:	eb003cb2 	bl	1a3d0 <__aeabi_uidiv>                          
    rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 
    worker->enabled = true;                                           
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dev = BDBUF_INVALID_DEV;                         
    b104:	e1a0800a 	mov	r8, sl                                        
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
    b108:	e58d000c 	str	r0, [sp, #12]                                 
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
    if (!worker)                                                      
      rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM); 
                                                                      
    rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 
    worker->enabled = true;                                           
    b10c:	e3a0a001 	mov	sl, #1                                        
rtems_bdbuf_swapout_workers_open (void)                               
{                                                                     
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    b110:	ebfffad9 	bl	9c7c <rtems_bdbuf_lock_cache>                  
    b114:	e1a06005 	mov	r6, r5                                        
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dev = BDBUF_INVALID_DEV;                         
                                                                      
    sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w), 
                            (bdbuf_config.swapout_priority ?          
    b118:	e5947008 	ldr	r7, [r4, #8]                                  
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
    b11c:	e594b014 	ldr	fp, [r4, #20]                                 
    b120:	ea000028 	b	b1c8 <rtems_bdbuf_swapout_task+0x124>           
  {                                                                   
    rtems_bdbuf_swapout_worker* worker;                               
                                                                      
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
    b124:	e3a00030 	mov	r0, #48	; 0x30                                <== NOT EXECUTED
    b128:	ebffdfef 	bl	30ec <malloc>                                  <== NOT EXECUTED
    if (!worker)                                                      
    b12c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
      rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM); 
    b130:	059f0278 	ldreq	r0, [pc, #632]	; b3b0 <rtems_bdbuf_swapout_task+0x30c><== NOT EXECUTED
    b134:	0a00001a 	beq	b1a4 <rtems_bdbuf_swapout_task+0x100>         <== 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 );                               
    b138:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    b13c:	e59f0270 	ldr	r0, [pc, #624]	; b3b4 <rtems_bdbuf_swapout_task+0x310><== NOT EXECUTED
    b140:	ebffef1e 	bl	6dc0 <_Chain_Append>                           <== NOT EXECUTED
                                                                      
    rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 
    worker->enabled = true;                                           
    b144:	e5c4a00c 	strb	sl, [r4, #12]                                <== NOT EXECUTED
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
    b148:	ebfffd57 	bl	a6ac <rtems_bdbuf_swapout_writereq_alloc>      <== NOT EXECUTED
    b14c:	e5840028 	str	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dev = BDBUF_INVALID_DEV;                         
                                                                      
    sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w), 
    b150:	e59f0260 	ldr	r0, [pc, #608]	; b3b8 <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    b154:	e2841014 	add	r1, r4, #20                                   <== NOT EXECUTED
    b158:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    b15c:	e2842010 	add	r2, r4, #16                                   <== NOT EXECUTED
    b160:	e2853061 	add	r3, r5, #97	; 0x61                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    b164:	e5841010 	str	r1, [r4, #16]                                 <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    b168:	e5842018 	str	r2, [r4, #24]                                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
    b16c:	e5846014 	str	r6, [r4, #20]                                 <== NOT EXECUTED
    rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 
    worker->enabled = true;                                           
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dev = BDBUF_INVALID_DEV;                         
    b170:	e584901c 	str	r9, [r4, #28]                                 <== NOT EXECUTED
    b174:	e5848020 	str	r8, [r4, #32]                                 <== NOT EXECUTED
                                                                      
    sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w), 
    b178:	e1830000 	orr	r0, r3, r0                                    <== NOT EXECUTED
    b17c:	11a01007 	movne	r1, r7                                      <== NOT EXECUTED
    b180:	03a0100f 	moveq	r1, #15                                     <== NOT EXECUTED
    b184:	e284c008 	add	ip, r4, #8                                    <== NOT EXECUTED
    b188:	e3a02a02 	mov	r2, #8192	; 0x2000                            <== NOT EXECUTED
    b18c:	e3a03b01 	mov	r3, #1024	; 0x400                             <== NOT EXECUTED
    b190:	e88d1040 	stm	sp, {r6, ip}                                  <== NOT EXECUTED
    b194:	ebffece7 	bl	6538 <rtems_task_create>                       <== NOT EXECUTED
                             RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT),
                            SWAPOUT_TASK_STACK_SIZE,                  
                            RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
                            RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,    
                            &worker->id);                             
    if (sc != RTEMS_SUCCESSFUL)                                       
    b198:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    b19c:	0a000001 	beq	b1a8 <rtems_bdbuf_swapout_task+0x104>         <== NOT EXECUTED
      rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
    b1a0:	e59f0214 	ldr	r0, [pc, #532]	; b3bc <rtems_bdbuf_swapout_task+0x318><== NOT EXECUTED
    b1a4:	ebffede4 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      
    sc = rtems_task_start (worker->id,                                
    b1a8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    b1ac:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    b1b0:	e59f1208 	ldr	r1, [pc, #520]	; b3c0 <rtems_bdbuf_swapout_task+0x31c><== NOT EXECUTED
    b1b4:	ebffed6f 	bl	6778 <rtems_task_start>                        <== NOT EXECUTED
                           rtems_bdbuf_swapout_worker_task,           
                           (rtems_task_argument) worker);             
    if (sc != RTEMS_SUCCESSFUL)                                       
    b1b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
    b1bc:	159f0200 	ldrne	r0, [pc, #512]	; b3c4 <rtems_bdbuf_swapout_task+0x320><== NOT EXECUTED
    b1c0:	1afffff7 	bne	b1a4 <rtems_bdbuf_swapout_task+0x100>         <== NOT EXECUTED
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
    b1c4:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    b1c8:	e155000b 	cmp	r5, fp                                        
    b1cc:	3affffd4 	bcc	b124 <rtems_bdbuf_swapout_task+0x80>          
   * here. We do not know the worker is the last in a sequence of sync writes
   * until after we have it running so we do not know to tell it to release the
   * lock. The simplest solution is to get the main swap out task perform all
   * sync operations.                                                 
   */                                                                 
  if (bdbuf_cache.sync_active)                                        
    b1d0:	e3a0b000 	mov	fp, #0                                        
                           (rtems_task_argument) worker);             
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    b1d4:	ebfffb21 	bl	9e60 <rtems_bdbuf_unlock_cache>                
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
    b1d8:	e59f51e8 	ldr	r5, [pc, #488]	; b3c8 <rtems_bdbuf_swapout_task+0x324>
   * here. We do not know the worker is the last in a sequence of sync writes
   * until after we have it running so we do not know to tell it to release the
   * lock. The simplest solution is to get the main swap out task perform all
   * sync operations.                                                 
   */                                                                 
  if (bdbuf_cache.sync_active)                                        
    b1dc:	e28d9010 	add	r9, sp, #16                                   
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
    b1e0:	ea000059 	b	b34c <rtems_bdbuf_swapout_task+0x2a8>           
    b1e4:	e3a07001 	mov	r7, #1                                        
                                rtems_bdbuf_swapout_transfer* transfer)
{                                                                     
  rtems_bdbuf_swapout_worker* worker;                                 
  bool                        transfered_buffers = false;             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    b1e8:	ebfffaa3 	bl	9c7c <rtems_bdbuf_lock_cache>                  
   * here. We do not know the worker is the last in a sequence of sync writes
   * until after we have it running so we do not know to tell it to release the
   * lock. The simplest solution is to get the main swap out task perform all
   * sync operations.                                                 
   */                                                                 
  if (bdbuf_cache.sync_active)                                        
    b1ec:	e5d53030 	ldrb	r3, [r5, #48]	; 0x30                         
    b1f0:	e3530000 	cmp	r3, #0                                        
    b1f4:	13a06000 	movne	r6, #0                                      
    b1f8:	1a000004 	bne	b210 <rtems_bdbuf_swapout_task+0x16c>         
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
    b1fc:	e59f01b0 	ldr	r0, [pc, #432]	; b3b4 <rtems_bdbuf_swapout_task+0x310>
    b200:	ebffef02 	bl	6e10 <_Chain_Get>                              
    worker = NULL;                                                    
  else                                                                
  {                                                                   
    worker = (rtems_bdbuf_swapout_worker*)                            
      rtems_chain_get (&bdbuf_cache.swapout_workers);                 
    if (worker)                                                       
    b204:	e2506000 	subs	r6, r0, #0                                   
      transfer = &worker->transfer;                                   
    b208:	12864010 	addne	r4, r6, #16                                 
    worker = NULL;                                                    
  else                                                                
  {                                                                   
    worker = (rtems_bdbuf_swapout_worker*)                            
      rtems_chain_get (&bdbuf_cache.swapout_workers);                 
    if (worker)                                                       
    b20c:	1a000000 	bne	b214 <rtems_bdbuf_swapout_task+0x170>         
    b210:	e1a04009 	mov	r4, r9                                        
      transfer = &worker->transfer;                                   
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dev = BDBUF_INVALID_DEV;                                  
  transfer->syncing = bdbuf_cache.sync_active;                        
    b214:	e5d53030 	ldrb	r3, [r5, #48]	; 0x30                         
    b218:	e5c43014 	strb	r3, [r4, #20]                                
  /*                                                                  
   * When the sync is for a device limit the sync to that device. If the sync
   * is for a buffer handle process the devices in the order on the sync
   * list. This means the dev is BDBUF_INVALID_DEV.                   
   */                                                                 
  if (bdbuf_cache.sync_active)                                        
    b21c:	e5d53030 	ldrb	r3, [r5, #48]	; 0x30                         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    b220:	e284a004 	add	sl, r4, #4                                    
    b224:	e3530000 	cmp	r3, #0                                        
    if (worker)                                                       
      transfer = &worker->transfer;                                   
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dev = BDBUF_INVALID_DEV;                                  
    b228:	e3e02000 	mvn	r2, #0                                        
    b22c:	e3e03000 	mvn	r3, #0                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    b230:	e8840c00 	stm	r4, {sl, fp}                                  
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
    b234:	e5844008 	str	r4, [r4, #8]                                  
    b238:	e584200c 	str	r2, [r4, #12]                                 
    b23c:	e5843010 	str	r3, [r4, #16]                                 
   * When the sync is for a device limit the sync to that device. If the sync
   * is for a buffer handle process the devices in the order on the sync
   * list. This means the dev is BDBUF_INVALID_DEV.                   
   */                                                                 
  if (bdbuf_cache.sync_active)                                        
    transfer->dev = bdbuf_cache.sync_device;                          
    b240:	12853038 	addne	r3, r5, #56	; 0x38                          
    b244:	1893000c 	ldmne	r3, {r2, r3}                                
    b248:	1584200c 	strne	r2, [r4, #12]                               
    b24c:	15843010 	strne	r3, [r4, #16]                               
                                                                      
  /*                                                                  
   * If we have any buffers in the sync queue move them to the modified
   * list. The first sync buffer will select the device we use.       
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dev,            
    b250:	e3a0c000 	mov	ip, #0                                        
    b254:	e284800c 	add	r8, r4, #12                                   
    b258:	e58dc000 	str	ip, [sp]                                      
    b25c:	e59dc008 	ldr	ip, [sp, #8]                                  
    b260:	e1a02004 	mov	r2, r4                                        
    b264:	e1a00008 	mov	r0, r8                                        
    b268:	e59f115c 	ldr	r1, [pc, #348]	; b3cc <rtems_bdbuf_swapout_task+0x328>
    b26c:	e3a03001 	mov	r3, #1                                        
    b270:	e58dc004 	str	ip, [sp, #4]                                  
    b274:	ebfffa91 	bl	9cc0 <rtems_bdbuf_swapout_modified_processing> 
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dev,            
    b278:	e59dc008 	ldr	ip, [sp, #8]                                  
                                           &bdbuf_cache.modified,     
                                           &transfer->bds,            
                                           bdbuf_cache.sync_active,   
    b27c:	e5d53030 	ldrb	r3, [r5, #48]	; 0x30                         
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dev,            
    b280:	e1a02004 	mov	r2, r4                                        
    b284:	e1a00008 	mov	r0, r8                                        
    b288:	e59f1140 	ldr	r1, [pc, #320]	; b3d0 <rtems_bdbuf_swapout_task+0x32c>
    b28c:	e88d1080 	stm	sp, {r7, ip}                                  
    b290:	ebfffa8a 	bl	9cc0 <rtems_bdbuf_swapout_modified_processing> 
  /*                                                                  
   * We have all the buffers that have been modified for this device so the
   * cache can be unlocked because the state of each buffer has been set to
   * TRANSFER.                                                        
   */                                                                 
  rtems_bdbuf_unlock_cache ();                                        
    b294:	ebfffaf1 	bl	9e60 <rtems_bdbuf_unlock_cache>                
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
    b298:	e5943000 	ldr	r3, [r4]                                      
    b29c:	e153000a 	cmp	r3, sl                                        
    b2a0:	03a04000 	moveq	r4, #0                                      
    b2a4:	0a00000b 	beq	b2d8 <rtems_bdbuf_swapout_task+0x234>         
  {                                                                   
    if (worker)                                                       
    b2a8:	e3560000 	cmp	r6, #0                                        
    b2ac:	0a000006 	beq	b2cc <rtems_bdbuf_swapout_task+0x228>         
    {                                                                 
      rtems_status_code sc = rtems_event_send (worker->id,            
    b2b0:	e5960008 	ldr	r0, [r6, #8]                                  <== NOT EXECUTED
    b2b4:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
    b2b8:	ebffeb1e 	bl	5f38 <rtems_event_send>                        <== NOT EXECUTED
                                               RTEMS_BDBUF_SWAPOUT_SYNC);
      if (sc != RTEMS_SUCCESSFUL)                                     
    b2bc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    b2c0:	0a000003 	beq	b2d4 <rtems_bdbuf_swapout_task+0x230>         <== NOT EXECUTED
        rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
    b2c4:	e59f0108 	ldr	r0, [pc, #264]	; b3d4 <rtems_bdbuf_swapout_task+0x330><== NOT EXECUTED
    b2c8:	eaffffb5 	b	b1a4 <rtems_bdbuf_swapout_task+0x100>           <== NOT EXECUTED
    }                                                                 
    else                                                              
    {                                                                 
      rtems_bdbuf_swapout_write (transfer);                           
    b2cc:	e1a00004 	mov	r0, r4                                        
    b2d0:	ebffff14 	bl	af28 <rtems_bdbuf_swapout_write>               
    b2d4:	e3a04001 	mov	r4, #1                                        
    }                                                                 
                                                                      
    transfered_buffers = true;                                        
  }                                                                   
                                                                      
  if (bdbuf_cache.sync_active && !transfered_buffers)                 
    b2d8:	e5d57030 	ldrb	r7, [r5, #48]	; 0x30                         
    b2dc:	e21770ff 	ands	r7, r7, #255	; 0xff                          
    b2e0:	e59f60e0 	ldr	r6, [pc, #224]	; b3c8 <rtems_bdbuf_swapout_task+0x324>
    b2e4:	0a00000d 	beq	b320 <rtems_bdbuf_swapout_task+0x27c>         
    b2e8:	e3540000 	cmp	r4, #0                                        
    b2ec:	e3a07000 	mov	r7, #0                                        
    b2f0:	1affffbc 	bne	b1e8 <rtems_bdbuf_swapout_task+0x144>         
  {                                                                   
    rtems_id sync_requester;                                          
    rtems_bdbuf_lock_cache ();                                        
    b2f4:	ebfffa60 	bl	9c7c <rtems_bdbuf_lock_cache>                  
    sync_requester = bdbuf_cache.sync_requester;                      
    b2f8:	e5967034 	ldr	r7, [r6, #52]	; 0x34                          
    bdbuf_cache.sync_active = false;                                  
    b2fc:	e5c64030 	strb	r4, [r6, #48]	; 0x30                         
    bdbuf_cache.sync_requester = 0;                                   
    b300:	e5864034 	str	r4, [r6, #52]	; 0x34                          
    rtems_bdbuf_unlock_cache ();                                      
    b304:	ebfffad5 	bl	9e60 <rtems_bdbuf_unlock_cache>                
    if (sync_requester)                                               
    b308:	e3570000 	cmp	r7, #0                                        
    b30c:	0a000005 	beq	b328 <rtems_bdbuf_swapout_task+0x284>         
      rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);   
    b310:	e1a00007 	mov	r0, r7                                        
    b314:	e3a01002 	mov	r1, #2                                        
    b318:	ebffeb06 	bl	5f38 <rtems_event_send>                        
    b31c:	ea000001 	b	b328 <rtems_bdbuf_swapout_task+0x284>           
      /*                                                              
       * Extact all the buffers we find for a specific device. The device is
       * the first one we find on a modified list. Process the sync queue of
       * buffers first.                                               
       */                                                             
      if (rtems_bdbuf_swapout_processing (timer_delta,                
    b320:	e3540000 	cmp	r4, #0                                        
    b324:	1affffaf 	bne	b1e8 <rtems_bdbuf_swapout_task+0x144>         
       */                                                             
      update_timers = false;                                          
    }                                                                 
    while (transfered_buffers);                                       
                                                                      
    sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,               
    b328:	e3a00004 	mov	r0, #4                                        
    b32c:	e3a01000 	mov	r1, #0                                        
    b330:	e59d200c 	ldr	r2, [sp, #12]                                 
    b334:	e28d3030 	add	r3, sp, #48	; 0x30                            
    b338:	ebffeaa2 	bl	5dc8 <rtems_event_receive>                     
                              RTEMS_EVENT_ALL | RTEMS_WAIT,           
                              period_in_ticks,                        
                              &out);                                  
                                                                      
    if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))            
    b33c:	e3500006 	cmp	r0, #6                                        
    b340:	13500000 	cmpne	r0, #0                                      
      rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);     
    b344:	159f008c 	ldrne	r0, [pc, #140]	; b3d8 <rtems_bdbuf_swapout_task+0x334>
    b348:	1affff95 	bne	b1a4 <rtems_bdbuf_swapout_task+0x100>         
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
    b34c:	e5d53004 	ldrb	r3, [r5, #4]                                 
    b350:	e21330ff 	ands	r3, r3, #255	; 0xff                          
    b354:	e59f406c 	ldr	r4, [pc, #108]	; b3c8 <rtems_bdbuf_swapout_task+0x324>
    b358:	1affffa1 	bne	b1e4 <rtems_bdbuf_swapout_task+0x140>         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    b35c:	e284600c 	add	r6, r4, #12                                   <== NOT EXECUTED
                                                                      
  node = rtems_chain_first (&bdbuf_cache.swapout_workers);            
  while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))   
  {                                                                   
    rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
    worker->enabled = false;                                          
    b360:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
static void                                                           
rtems_bdbuf_swapout_workers_close (void)                              
{                                                                     
  rtems_chain_node* node;                                             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
    b364:	ebfffa44 	bl	9c7c <rtems_bdbuf_lock_cache>                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->first;                                            
    b368:	e5944008 	ldr	r4, [r4, #8]                                  <== NOT EXECUTED
    b36c:	ea000004 	b	b384 <rtems_bdbuf_swapout_task+0x2e0>           <== NOT EXECUTED
                                                                      
  node = rtems_chain_first (&bdbuf_cache.swapout_workers);            
  while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))   
  {                                                                   
    rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
    worker->enabled = false;                                          
    b370:	e5c4500c 	strb	r5, [r4, #12]                                <== NOT EXECUTED
    rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);          
    b374:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    b378:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
    b37c:	ebffeaed 	bl	5f38 <rtems_event_send>                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
    b380:	e5944000 	ldr	r4, [r4]                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    b384:	e1540006 	cmp	r4, r6                                        <== NOT EXECUTED
    b388:	1afffff8 	bne	b370 <rtems_bdbuf_swapout_task+0x2cc>         <== NOT EXECUTED
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    b38c:	ebfffab3 	bl	9e60 <rtems_bdbuf_unlock_cache>                <== NOT EXECUTED
      rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);     
  }                                                                   
                                                                      
  rtems_bdbuf_swapout_workers_close ();                               
                                                                      
  free (transfer.write_req);                                          
    b390:	e59d0028 	ldr	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
    b394:	ebffde88 	bl	2dbc <free>                                    <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
    b398:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    b39c:	ebffecb7 	bl	6680 <rtems_task_delete>                       <== NOT EXECUTED
}                                                                     
    b3a0:	e28dd034 	add	sp, sp, #52	; 0x34                            <== NOT EXECUTED
    b3a4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0000b3dc <rtems_bdbuf_swapout_worker_task>: * @param arg A pointer to the worker thread's private data. * @return rtems_task Not used. */ static rtems_task rtems_bdbuf_swapout_worker_task (rtems_task_argument arg) {
    b3dc:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
    b3e0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  while (worker->enabled)                                             
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
                                                                      
    rtems_bdbuf_swapout_write (&worker->transfer);                    
    b3e4:	e2805010 	add	r5, r0, #16                                   <== NOT EXECUTED
    b3e8:	e280a014 	add	sl, r0, #20                                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
    b3ec:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
                                                                      
    rtems_bdbuf_lock_cache ();                                        
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dev = BDBUF_INVALID_DEV;                         
    b3f0:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
    b3f4:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
static rtems_task                                                     
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)             
{                                                                     
  rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
                                                                      
  while (worker->enabled)                                             
    b3f8:	ea00000c 	b	b430 <rtems_bdbuf_swapout_worker_task+0x54>     <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
    b3fc:	ebfffb2f 	bl	a0c0 <rtems_bdbuf_wait_for_event>              <== NOT EXECUTED
                                                                      
    rtems_bdbuf_swapout_write (&worker->transfer);                    
    b400:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    b404:	ebfffec7 	bl	af28 <rtems_bdbuf_swapout_write>               <== NOT EXECUTED
                                                                      
    rtems_bdbuf_lock_cache ();                                        
    b408:	ebfffa1b 	bl	9c7c <rtems_bdbuf_lock_cache>                  <== 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 );                               
    b40c:	e59f0048 	ldr	r0, [pc, #72]	; b45c <rtems_bdbuf_swapout_worker_task+0x80><== NOT EXECUTED
    b410:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
    b414:	e584a010 	str	sl, [r4, #16]                                 <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
    b418:	e5848014 	str	r8, [r4, #20]                                 <== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);                 
    b41c:	e5845018 	str	r5, [r4, #24]                                 <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dev = BDBUF_INVALID_DEV;                         
    b420:	e584601c 	str	r6, [r4, #28]                                 <== NOT EXECUTED
    b424:	e5847020 	str	r7, [r4, #32]                                 <== NOT EXECUTED
    b428:	ebffee64 	bl	6dc0 <_Chain_Append>                           <== NOT EXECUTED
                                                                      
    rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
    b42c:	ebfffa8b 	bl	9e60 <rtems_bdbuf_unlock_cache>                <== NOT EXECUTED
static rtems_task                                                     
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)             
{                                                                     
  rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
                                                                      
  while (worker->enabled)                                             
    b430:	e5d4900c 	ldrb	r9, [r4, #12]                                <== NOT EXECUTED
    b434:	e21990ff 	ands	r9, r9, #255	; 0xff                          <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
    b438:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
static rtems_task                                                     
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)             
{                                                                     
  rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
                                                                      
  while (worker->enabled)                                             
    b43c:	1affffee 	bne	b3fc <rtems_bdbuf_swapout_worker_task+0x20>   <== NOT EXECUTED
    rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
  }                                                                   
                                                                      
  free (worker->transfer.write_req);                                  
    b440:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
    b444:	ebffde5c 	bl	2dbc <free>                                    <== NOT EXECUTED
  free (worker);                                                      
    b448:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    b44c:	ebffde5a 	bl	2dbc <free>                                    <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
    b450:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
}                                                                     
    b454:	e8bd47f0 	pop	{r4, r5, r6, r7, r8, r9, sl, lr}              <== NOT EXECUTED
  }                                                                   
                                                                      
  free (worker->transfer.write_req);                                  
  free (worker);                                                      
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
    b458:	eaffec88 	b	6680 <rtems_task_delete>                        <== NOT EXECUTED
                                                                      

0000af28 <rtems_bdbuf_swapout_write>: printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev); /* * If there are buffers to transfer to the media transfer them. */ if (!rtems_chain_is_empty (&transfer->bds))
    af28:	e5903000 	ldr	r3, [r0]                                      
 *                                                                    
 * @param transfer The transfer transaction.                          
 */                                                                   
static void                                                           
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)    
{                                                                     
    af2c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    af30:	e2807004 	add	r7, r0, #4                                    
    printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
    af34:	e1530007 	cmp	r3, r7                                        
 *                                                                    
 * @param transfer The transfer transaction.                          
 */                                                                   
static void                                                           
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)    
{                                                                     
    af38:	e1a04000 	mov	r4, r0                                        
    printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
    af3c:	08bd8ff0 	popeq	{r4, r5, r6, r7, r8, r9, sl, fp, pc}        
                                                                      
    /*                                                                
     * Obtain the disk device. The cache's mutex has been released to avoid a
     * dead lock.                                                     
     */                                                               
    rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);        
    af40:	e280100c 	add	r1, r0, #12                                   
    af44:	e8910003 	ldm	r1, {r0, r1}                                  
    af48:	ebffdbcf 	bl	1e8c <rtems_disk_obtain>                       
                                                                      
    if (dd == NULL)                                                   
      dd = &null_disk;                                                
                                                                      
    bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;           
    af4c:	e59f9148 	ldr	r9, [pc, #328]	; b09c <rtems_bdbuf_swapout_write+0x174>
     * Obtain the disk device. The cache's mutex has been released to avoid a
     * dead lock.                                                     
     */                                                               
    rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);        
                                                                      
    if (dd == NULL)                                                   
    af50:	e3500000 	cmp	r0, #0                                        
    af54:	e59f5144 	ldr	r5, [pc, #324]	; b0a0 <rtems_bdbuf_swapout_write+0x178>
    af58:	11a05000 	movne	r5, r0                                      
      dd = &null_disk;                                                
                                                                      
    bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;           
    af5c:	e5950020 	ldr	r0, [r5, #32]                                 
    af60:	e5991020 	ldr	r1, [r9, #32]                                 
    af64:	eb003d19 	bl	1a3d0 <__aeabi_uidiv>                          
     * should be possible to make this change with little effect in this
     * code. The array that is passed is broken in design and should be
     * removed. Merging members of a struct into the first member is  
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    af68:	e5943018 	ldr	r3, [r4, #24]                                 
    transfer->write_req->bufnum = 0;                                  
    af6c:	e3a02000 	mov	r2, #0                                        
     * should be possible to make this change with little effect in this
     * code. The array that is passed is broken in design and should be
     * removed. Merging members of a struct into the first member is  
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    af70:	e3a0800c 	mov	r8, #12                                       
       * Perform the transfer if there are no more buffers, or the transfer
       * size has reached the configured max. value.                  
       */                                                             
                                                                      
      if (rtems_chain_is_empty (&transfer->bds) ||                    
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
    af74:	e599b004 	ldr	fp, [r9, #4]                                  
    rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);        
                                                                      
    if (dd == NULL)                                                   
      dd = &null_disk;                                                
                                                                      
    bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;           
    af78:	e1a0a000 	mov	sl, r0                                        
       * Perform the transfer if there are no more buffers, or the transfer
       * size has reached the configured max. value.                  
       */                                                             
                                                                      
      if (rtems_chain_is_empty (&transfer->bds) ||                    
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
    af7c:	e1a06002 	mov	r6, r2                                        
     * code. The array that is passed is broken in design and should be
     * removed. Merging members of a struct into the first member is  
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    transfer->write_req->bufnum = 0;                                  
    af80:	e5832010 	str	r2, [r3, #16]                                 
     * should be possible to make this change with little effect in this
     * code. The array that is passed is broken in design and should be
     * removed. Merging members of a struct into the first member is  
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    af84:	e583800c 	str	r8, [r3, #12]                                 
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
        buf->buffer = bd->buffer;                                     
        last_block  = bd->block;                                      
    af88:	e1a09002 	mov	r9, r2                                        
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    transfer->write_req->bufnum = 0;                                  
                                                                      
    while ((node = rtems_chain_get(&transfer->bds)) != NULL)          
    af8c:	ea00002f 	b	b050 <rtems_bdbuf_swapout_write+0x128>          
        printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
                bd->block, transfer->write_req->bufnum,               
                dd->phys_dev->capabilities &                          
                RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
                                                                      
      if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
    af90:	e5953008 	ldr	r3, [r5, #8]                                  
    af94:	e593300c 	ldr	r3, [r3, #12]                                 
    af98:	e3130001 	tst	r3, #1                                        
    af9c:	0a00000c 	beq	afd4 <rtems_bdbuf_swapout_write+0xac>         
          transfer->write_req->bufnum &&                              
    afa0:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
    afa4:	e5931010 	ldr	r1, [r3, #16]                                 <== NOT EXECUTED
    afa8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
          (bd->block != (last_block + bufs_per_bd)))                  
    afac:	e086300a 	add	r3, r6, sl                                    <== NOT EXECUTED
                bd->block, transfer->write_req->bufnum,               
                dd->phys_dev->capabilities &                          
                RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
                                                                      
      if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
          transfer->write_req->bufnum &&                              
    afb0:	0a000007 	beq	afd4 <rtems_bdbuf_swapout_write+0xac>         <== NOT EXECUTED
          (bd->block != (last_block + bufs_per_bd)))                  
    afb4:	e592101c 	ldr	r1, [r2, #28]                                 <== NOT EXECUTED
    afb8:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
    afbc:	0a000004 	beq	afd4 <rtems_bdbuf_swapout_write+0xac>         <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(                             
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert(_Chain_Head(the_chain), the_node);                    
    afc0:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
    afc4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    afc8:	eb000e94 	bl	ea20 <_Chain_Insert>                           <== NOT EXECUTED
    afcc:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
        printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
                bd->block, transfer->write_req->bufnum,               
                dd->phys_dev->capabilities &                          
                RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
                                                                      
      if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
    afd0:	ea00000e 	b	b010 <rtems_bdbuf_swapout_write+0xe8>           <== NOT EXECUTED
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
    afd4:	e5943018 	ldr	r3, [r4, #24]                                 
    afd8:	e5930010 	ldr	r0, [r3, #16]                                 
        transfer->write_req->bufnum++;                                
    afdc:	e2801001 	add	r1, r0, #1                                    
    afe0:	e5831010 	str	r1, [r3, #16]                                 
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
    afe4:	e592c01c 	ldr	ip, [r2, #28]                                 
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
    afe8:	e0831200 	add	r1, r3, r0, lsl #4                            
        buf->block  = bd->block;                                      
    afec:	e581c018 	str	ip, [r1, #24]                                 
        buf->length = dd->block_size;                                 
    aff0:	e595c020 	ldr	ip, [r5, #32]                                 
    aff4:	e581c01c 	str	ip, [r1, #28]                                 
        buf->buffer = bd->buffer;                                     
    aff8:	e592c020 	ldr	ip, [r2, #32]                                 
    affc:	e2800002 	add	r0, r0, #2                                    
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
    b000:	e5812024 	str	r2, [r1, #36]	; 0x24                          
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
        buf->buffer = bd->buffer;                                     
        last_block  = bd->block;                                      
    b004:	e592601c 	ldr	r6, [r2, #28]                                 
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
        buf->buffer = bd->buffer;                                     
    b008:	e783c200 	str	ip, [r3, r0, lsl #4]                          
        last_block  = bd->block;                                      
    b00c:	e3a03000 	mov	r3, #0                                        
      /*                                                              
       * Perform the transfer if there are no more buffers, or the transfer
       * size has reached the configured max. value.                  
       */                                                             
                                                                      
      if (rtems_chain_is_empty (&transfer->bds) ||                    
    b010:	e5942000 	ldr	r2, [r4]                                      
    b014:	e1520007 	cmp	r2, r7                                        
    b018:	0a000005 	beq	b034 <rtems_bdbuf_swapout_write+0x10c>        
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
    b01c:	e5942018 	ldr	r2, [r4, #24]                                 
    b020:	e5922010 	ldr	r2, [r2, #16]                                 
    b024:	e152000b 	cmp	r2, fp                                        
    b028:	2a000001 	bcs	b034 <rtems_bdbuf_swapout_write+0x10c>        
        write = true;                                                 
                                                                      
      if (write)                                                      
    b02c:	e3530000 	cmp	r3, #0                                        
    b030:	0a000006 	beq	b050 <rtems_bdbuf_swapout_write+0x128>        
      {                                                               
        rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
    b034:	e1a00005 	mov	r0, r5                                        
    b038:	e5941018 	ldr	r1, [r4, #24]                                 
    b03c:	e3a02000 	mov	r2, #0                                        
    b040:	ebffff77 	bl	ae24 <rtems_bdbuf_execute_transfer_request>    
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
    b044:	e5943018 	ldr	r3, [r4, #24]                                 
        transfer->write_req->bufnum = 0;                              
    b048:	e5839010 	str	r9, [r3, #16]                                 
                                                                      
      if (write)                                                      
      {                                                               
        rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
    b04c:	e583800c 	str	r8, [r3, #12]                                 
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
    b050:	e1a00004 	mov	r0, r4                                        
    b054:	ebffef6d 	bl	6e10 <_Chain_Get>                              
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    transfer->write_req->bufnum = 0;                                  
                                                                      
    while ((node = rtems_chain_get(&transfer->bds)) != NULL)          
    b058:	e2502000 	subs	r2, r0, #0                                   
    b05c:	1affffcb 	bne	af90 <rtems_bdbuf_swapout_write+0x68>         
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
        transfer->write_req->bufnum = 0;                              
      }                                                               
    }                                                                 
                                                                      
    if (dd != &null_disk)                                             
    b060:	e59f3038 	ldr	r3, [pc, #56]	; b0a0 <rtems_bdbuf_swapout_write+0x178>
    b064:	e1550003 	cmp	r5, r3                                        
    b068:	08bd8ff0 	popeq	{r4, r5, r6, r7, r8, r9, sl, fp, pc}        
    {                                                                 
      /*                                                              
       * If sync'ing and the deivce is capability of handling a sync IO control
       * call perform the call.                                       
       */                                                             
      if (transfer->syncing &&                                        
    b06c:	e5d43014 	ldrb	r3, [r4, #20]                                
    b070:	e3530000 	cmp	r3, #0                                        
    b074:	0a000005 	beq	b090 <rtems_bdbuf_swapout_write+0x168>        
          (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))       
    b078:	e5950008 	ldr	r0, [r5, #8]                                  
    {                                                                 
      /*                                                              
       * If sync'ing and the deivce is capability of handling a sync IO control
       * call perform the call.                                       
       */                                                             
      if (transfer->syncing &&                                        
    b07c:	e590300c 	ldr	r3, [r0, #12]                                 
    b080:	e3130002 	tst	r3, #2                                        
          (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))       
      {                                                               
        /* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
    b084:	13a01002 	movne	r1, #2                                      
    b088:	11a0e00f 	movne	lr, pc                                      
    b08c:	1595f028 	ldrne	pc, [r5, #40]	; 0x28                        
        /* How should the error be handled ? */                       
      }                                                               
                                                                      
      rtems_disk_release (dd);                                        
    b090:	e1a00005 	mov	r0, r5                                        
    }                                                                 
  }                                                                   
}                                                                     
    b094:	e8bd4ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, lr}          
      {                                                               
        /* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
        /* How should the error be handled ? */                       
      }                                                               
                                                                      
      rtems_disk_release (dd);                                        
    b098:	eaffdbf7 	b	207c <rtems_disk_release>                       
                                                                      

0000b460 <rtems_bdbuf_sync>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_bdbuf_sync (rtems_bdbuf_buffer *bd) {
    b460:	e92d4030 	push	{r4, r5, lr}                                 
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (!bdbuf_cache.initialised)                                       
    b464:	e59f514c 	ldr	r5, [pc, #332]	; b5b8 <rtems_bdbuf_sync+0x158>
    b468:	e5d53088 	ldrb	r3, [r5, #136]	; 0x88                        
    b46c:	e3530000 	cmp	r3, #0                                        
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)                             
{                                                                     
    b470:	e1a04000 	mov	r4, r0                                        
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");              
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
    b474:	03a00016 	moveq	r0, #22                                     
}                                                                     
                                                                      
static rtems_status_code                                              
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{                                                                     
  if (!bdbuf_cache.initialised)                                       
    b478:	08bd8030 	popeq	{r4, r5, pc}                                
    return RTEMS_NOT_CONFIGURED;                                      
  if (bd == NULL)                                                     
    b47c:	e3540000 	cmp	r4, #0                                        
    b480:	03a00009 	moveq	r0, #9                                      
    b484:	08bd8030 	popeq	{r4, r5, pc}                                
  if (rtems_bdbuf_tracer)                                             
  {                                                                   
    printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);              
    rtems_bdbuf_show_users (kind, bd);                                
  }                                                                   
  rtems_bdbuf_lock_cache();                                           
    b488:	ebfff9fb 	bl	9c7c <rtems_bdbuf_lock_cache>                  
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");              
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
    b48c:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
    b490:	e3530003 	cmp	r3, #3                                        
    b494:	3a00003f 	bcc	b598 <rtems_bdbuf_sync+0x138>                 
    b498:	e3530005 	cmp	r3, #5                                        
    b49c:	9a000002 	bls	b4ac <rtems_bdbuf_sync+0x4c>                  
    b4a0:	e3530006 	cmp	r3, #6                                        
    b4a4:	1a00003b 	bne	b598 <rtems_bdbuf_sync+0x138>                 
    b4a8:	ea000037 	b	b58c <rtems_bdbuf_sync+0x12c>                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    b4ac:	e3a03008 	mov	r3, #8                                        
    b4b0:	e5843024 	str	r3, [r4, #36]	; 0x24                          
    b4b4:	e285005c 	add	r0, r5, #92	; 0x5c                            
    b4b8:	e1a01004 	mov	r1, r4                                        
    b4bc:	ebffee3f 	bl	6dc0 <_Chain_Append>                           
{                                                                     
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);                 
                                                                      
  rtems_chain_append (&bdbuf_cache.sync, &bd->link);                  
                                                                      
  if (bd->waiters)                                                    
    b4c0:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
    b4c4:	e3530000 	cmp	r3, #0                                        
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
    b4c8:	12850068 	addne	r0, r5, #104	; 0x68                         
    b4cc:	1bfff9f0 	blne	9c94 <rtems_bdbuf_wake>                      
                                                                      
  rtems_bdbuf_wake_swapper ();                                        
    b4d0:	ebfffaba 	bl	9fc0 <rtems_bdbuf_wake_swapper>                
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
    b4d4:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
    b4d8:	e2433001 	sub	r3, r3, #1                                    
    b4dc:	e3530009 	cmp	r3, #9                                        
    b4e0:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
    b4e4:	ea00000d 	b	b520 <rtems_bdbuf_sync+0xc0>                    <== NOT EXECUTED
    b4e8:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b4ec:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b4f0:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b4f4:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b4f8:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b4fc:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b500:	0000b534 	.word	0x0000b534                                  <== NOT EXECUTED
    b504:	0000b510 	.word	0x0000b510                                  <== NOT EXECUTED
    b508:	0000b510 	.word	0x0000b510                                  <== NOT EXECUTED
    b50c:	0000b510 	.word	0x0000b510                                  <== NOT EXECUTED
      case RTEMS_BDBUF_STATE_ACCESS_PURGED:                           
        return;                                                       
      case RTEMS_BDBUF_STATE_SYNC:                                    
      case RTEMS_BDBUF_STATE_TRANSFER:                                
      case RTEMS_BDBUF_STATE_TRANSFER_PURGED:                         
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);         
    b510:	e1a00004 	mov	r0, r4                                        
    b514:	e59f10a0 	ldr	r1, [pc, #160]	; b5bc <rtems_bdbuf_sync+0x15c>
    b518:	ebfffb51 	bl	a264 <rtems_bdbuf_wait>                        
    b51c:	eaffffec 	b	b4d4 <rtems_bdbuf_sync+0x74>                    
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
    b520:	e5940024 	ldr	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    b524:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    b528:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    b52c:	e3800007 	orr	r0, r0, #7                                    <== NOT EXECUTED
    b530:	ea00001c 	b	b5a8 <rtems_bdbuf_sync+0x148>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   * We may have created a cached or empty buffer which may be recycled.
   */                                                                 
  if (bd->waiters == 0                                                
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
    b534:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
  rtems_bdbuf_wait_for_sync_done (bd);                                
                                                                      
  /*                                                                  
   * We may have created a cached or empty buffer which may be recycled.
   */                                                                 
  if (bd->waiters == 0                                                
    b538:	e3530000 	cmp	r3, #0                                        
    b53c:	1a00001a 	bne	b5ac <rtems_bdbuf_sync+0x14c>                 
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
    b540:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
  rtems_bdbuf_wait_for_sync_done (bd);                                
                                                                      
  /*                                                                  
   * We may have created a cached or empty buffer which may be recycled.
   */                                                                 
  if (bd->waiters == 0                                                
    b544:	e3530002 	cmp	r3, #2                                        
    b548:	0a000002 	beq	b558 <rtems_bdbuf_sync+0xf8>                  
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
    b54c:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
  rtems_bdbuf_wait_for_sync_done (bd);                                
                                                                      
  /*                                                                  
   * We may have created a cached or empty buffer which may be recycled.
   */                                                                 
  if (bd->waiters == 0                                                
    b550:	e3530001 	cmp	r3, #1                                        
    b554:	1a000014 	bne	b5ac <rtems_bdbuf_sync+0x14c>                 
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
  {                                                                   
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                         
    b558:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          
    b55c:	e3530001 	cmp	r3, #1                                        
    b560:	1a000006 	bne	b580 <rtems_bdbuf_sync+0x120>                 
    {                                                                 
      rtems_bdbuf_remove_from_tree (bd);                              
    b564:	e1a00004 	mov	r0, r4                                        
    b568:	ebfffc63 	bl	a6fc <rtems_bdbuf_remove_from_tree>            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
    b56c:	e3a03000 	mov	r3, #0                                        
    b570:	e5843024 	str	r3, [r4, #36]	; 0x24                          
RTEMS_INLINE_ROUTINE void _Chain_Prepend(                             
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert(_Chain_Head(the_chain), the_node);                    
    b574:	e1a01004 	mov	r1, r4                                        
    b578:	e59f0040 	ldr	r0, [pc, #64]	; b5c0 <rtems_bdbuf_sync+0x160> 
    b57c:	eb000d27 	bl	ea20 <_Chain_Insert>                           
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                         
    {                                                                 
      rtems_bdbuf_remove_from_tree (bd);                              
      rtems_bdbuf_make_free_and_add_to_lru_list (bd);                 
    }                                                                 
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
    b580:	e59f003c 	ldr	r0, [pc, #60]	; b5c4 <rtems_bdbuf_sync+0x164> 
    b584:	ebfff9c2 	bl	9c94 <rtems_bdbuf_wake>                        
    b588:	ea000007 	b	b5ac <rtems_bdbuf_sync+0x14c>                   
    case RTEMS_BDBUF_STATE_ACCESS_EMPTY:                              
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_sync_after_access (bd);                             
      break;                                                          
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
    b58c:	e1a00004 	mov	r0, r4                                        
    b590:	ebfffd4c 	bl	aac8 <rtems_bdbuf_discard_buffer_after_access> 
      break;                                                          
    b594:	ea000004 	b	b5ac <rtems_bdbuf_sync+0x14c>                   
    default:                                                          
      rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
    b598:	e5940024 	ldr	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
#endif                                                                
                                                                      
static void                                                           
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)       
{                                                                     
  rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);    
    b59c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
    b5a0:	e3800442 	orr	r0, r0, #1107296256	; 0x42000000              <== NOT EXECUTED
    b5a4:	e3800003 	orr	r0, r0, #3                                    <== NOT EXECUTED
    b5a8:	ebffece3 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
    b5ac:	ebfffa2b 	bl	9e60 <rtems_bdbuf_unlock_cache>                
    b5b0:	e3a00000 	mov	r0, #0                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    b5b4:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

00009e60 <rtems_bdbuf_unlock_cache>: * @param fatal_error_code The error code if the call fails. */ static void rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code) { rtems_status_code sc = rtems_semaphore_release (lock);
    9e60:	e59f3018 	ldr	r3, [pc, #24]	; 9e80 <rtems_bdbuf_unlock_cache+0x20>
/**                                                                   
 * Unlock the cache.                                                  
 */                                                                   
static void                                                           
rtems_bdbuf_unlock_cache (void)                                       
{                                                                     
    9e64:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
 * @param fatal_error_code The error code if the call fails.          
 */                                                                   
static void                                                           
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)         
{                                                                     
  rtems_status_code sc = rtems_semaphore_release (lock);              
    9e68:	e5930028 	ldr	r0, [r3, #40]	; 0x28                          
    9e6c:	ebfff18a 	bl	649c <rtems_semaphore_release>                 
  if (sc != RTEMS_SUCCESSFUL)                                         
    9e70:	e3500000 	cmp	r0, #0                                        
    9e74:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
    rtems_fatal_error_occurred (fatal_error_code);                    
    9e78:	e59f0004 	ldr	r0, [pc, #4]	; 9e84 <rtems_bdbuf_unlock_cache+0x24><== NOT EXECUTED
    9e7c:	ebfff2ae 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

00009e88 <rtems_bdbuf_unlock_sync>: * @param fatal_error_code The error code if the call fails. */ static void rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code) { rtems_status_code sc = rtems_semaphore_release (lock);
    9e88:	e59f3018 	ldr	r3, [pc, #24]	; 9ea8 <rtems_bdbuf_unlock_sync+0x20>
/**                                                                   
 * Unlock the cache's sync lock. Any blocked writers are woken.       
 */                                                                   
static void                                                           
rtems_bdbuf_unlock_sync (void)                                        
{                                                                     
    9e8c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
 * @param fatal_error_code The error code if the call fails.          
 */                                                                   
static void                                                           
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)         
{                                                                     
  rtems_status_code sc = rtems_semaphore_release (lock);              
    9e90:	e593002c 	ldr	r0, [r3, #44]	; 0x2c                          
    9e94:	ebfff180 	bl	649c <rtems_semaphore_release>                 
  if (sc != RTEMS_SUCCESSFUL)                                         
    9e98:	e3500000 	cmp	r0, #0                                        
    9e9c:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
    rtems_fatal_error_occurred (fatal_error_code);                    
    9ea0:	e59f0004 	ldr	r0, [pc, #4]	; 9eac <rtems_bdbuf_unlock_sync+0x24><== NOT EXECUTED
    9ea4:	ebfff2a4 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

0000a0c0 <rtems_bdbuf_wait_for_event>: return RTEMS_UNSATISFIED; } static void rtems_bdbuf_wait_for_event (rtems_event_set event) {
    a0c0:	e92d4011 	push	{r0, r4, lr}                                 
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_event_set   out = 0;                                          
    a0c4:	e3a01000 	mov	r1, #0                                        
    a0c8:	e28d3004 	add	r3, sp, #4                                    
    a0cc:	e5231004 	str	r1, [r3, #-4]!                                
                                                                      
  sc = rtems_event_receive (event,                                    
    a0d0:	e1a02001 	mov	r2, r1                                        
    a0d4:	e1a0300d 	mov	r3, sp                                        
  return RTEMS_UNSATISFIED;                                           
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_event (rtems_event_set event)                    
{                                                                     
    a0d8:	e1a04000 	mov	r4, r0                                        
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_event_set   out = 0;                                          
                                                                      
  sc = rtems_event_receive (event,                                    
    a0dc:	ebffef39 	bl	5dc8 <rtems_event_receive>                     
                            RTEMS_EVENT_ALL | RTEMS_WAIT,             
                            RTEMS_NO_TIMEOUT,                         
                            &out);                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL || out != event)                         
    a0e0:	e3500000 	cmp	r0, #0                                        
    a0e4:	1a000002 	bne	a0f4 <rtems_bdbuf_wait_for_event+0x34>        
    a0e8:	e59d3000 	ldr	r3, [sp]                                      
    a0ec:	e1530004 	cmp	r3, r4                                        
    a0f0:	0a000001 	beq	a0fc <rtems_bdbuf_wait_for_event+0x3c>        
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);  
    a0f4:	e59f0004 	ldr	r0, [pc, #4]	; a100 <rtems_bdbuf_wait_for_event+0x40><== NOT EXECUTED
    a0f8:	ebfff20f 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
}                                                                     
    a0fc:	e8bd8018 	pop	{r3, r4, pc}                                  
                                                                      

00009c94 <rtems_bdbuf_wake>: static void rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters) { rtems_status_code sc = RTEMS_SUCCESSFUL; if (waiters->count > 0)
    9c94:	e5903000 	ldr	r3, [r0]                                      
    9c98:	e3530000 	cmp	r3, #0                                        
 * Wake a blocked resource. The resource has a counter that lets us know if
 * there are any waiters.                                             
 */                                                                   
static void                                                           
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)                 
{                                                                     
    9c9c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (waiters->count > 0)                                             
    9ca0:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
  {                                                                   
    sc = rtems_semaphore_flush (waiters->sema);                       
    9ca4:	e5900004 	ldr	r0, [r0, #4]                                  
    9ca8:	eb001215 	bl	e504 <rtems_semaphore_flush>                   
    if (sc != RTEMS_SUCCESSFUL)                                       
    9cac:	e3500000 	cmp	r0, #0                                        
    9cb0:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
      rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
    9cb4:	e59f0000 	ldr	r0, [pc, #0]	; 9cbc <rtems_bdbuf_wake+0x28>   <== NOT EXECUTED
    9cb8:	ebfff31f 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

00009fc0 <rtems_bdbuf_wake_swapper>: } static void rtems_bdbuf_wake_swapper (void) { rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
    9fc0:	e59f301c 	ldr	r3, [pc, #28]	; 9fe4 <rtems_bdbuf_wake_swapper+0x24>
  }                                                                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wake_swapper (void)                                       
{                                                                     
    9fc4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,       
    9fc8:	e5930000 	ldr	r0, [r3]                                      
    9fcc:	e3a01004 	mov	r1, #4                                        
    9fd0:	ebffefd8 	bl	5f38 <rtems_event_send>                        
                                           RTEMS_BDBUF_SWAPOUT_SYNC); 
  if (sc != RTEMS_SUCCESSFUL)                                         
    9fd4:	e3500000 	cmp	r0, #0                                        
    9fd8:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
    rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);    
    9fdc:	e59f0004 	ldr	r0, [pc, #4]	; 9fe8 <rtems_bdbuf_wake_swapper+0x28><== NOT EXECUTED
    9fe0:	ebfff255 	bl	693c <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      

000206fc <rtems_bdpart_create>: const rtems_bdpart_format *format, rtems_bdpart_partition *pt, const unsigned *dist, size_t count ) {
   206fc:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
   20700:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
  const rtems_bdpart_format *format,                                  
  rtems_bdpart_partition *pt,                                         
  const unsigned *dist,                                               
  size_t count                                                        
)                                                                     
{                                                                     
   20704:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
   20708:	e98d000c 	stmib	sp, {r2, r3}                                <== NOT EXECUTED
   2070c:	e59d5040 	ldr	r5, [sp, #64]	; 0x40                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
   20710:	0a000003 	beq	20724 <rtems_bdpart_create+0x28>              <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
   20714:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   20718:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   2071c:	05d48008 	ldrbeq	r8, [r4, #8]                               <== NOT EXECUTED
   20720:	0a000000 	beq	20728 <rtems_bdpart_create+0x2c>              <== NOT EXECUTED
   20724:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
    && format->mbr.dos_compatibility;                                 
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum pos = 0;                                          
  rtems_blkdev_bnum dist_sum = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
   20728:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   2072c:	13a0603f 	movne	r6, #63	; 0x3f                              <== NOT EXECUTED
   20730:	03a06001 	moveq	r6, #1                                      <== NOT EXECUTED
  rtems_blkdev_bnum free_space = 0;                                   
  dev_t disk = 0;                                                     
  size_t i = 0;                                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
   20734:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    && format->mbr.dos_compatibility;                                 
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum pos = 0;                                          
  rtems_blkdev_bnum dist_sum = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
   20738:	e20880ff 	and	r8, r8, #255	; 0xff                           <== NOT EXECUTED
  rtems_blkdev_bnum free_space = 0;                                   
  dev_t disk = 0;                                                     
  size_t i = 0;                                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
   2073c:	01a07005 	moveq	r7, r5                                      <== NOT EXECUTED
   20740:	0a00006a 	beq	208f0 <rtems_bdpart_create+0x1f4>             <== NOT EXECUTED
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || dist == NULL) {                 
   20744:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   20748:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   2074c:	13510000 	cmpne	r1, #0                                      <== NOT EXECUTED
   20750:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   20754:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   20758:	0a000061 	beq	208e4 <rtems_bdpart_create+0x1e8>             <== NOT EXECUTED
   2075c:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   20760:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   20764:	0a00005e 	beq	208e4 <rtems_bdpart_create+0x1e8>             <== NOT EXECUTED
  rtems_blkdev_bnum dist_sum = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
  rtems_blkdev_bnum overhead = 0;                                     
  rtems_blkdev_bnum free_space = 0;                                   
  dev_t disk = 0;                                                     
   20768:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
  if (format == NULL || pt == NULL || dist == NULL) {                 
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
   2076c:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
   20770:	e28d2018 	add	r2, sp, #24                                   <== NOT EXECUTED
  rtems_blkdev_bnum dist_sum = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
  rtems_blkdev_bnum overhead = 0;                                     
  rtems_blkdev_bnum free_space = 0;                                   
  dev_t disk = 0;                                                     
   20774:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   20778:	e58da010 	str	sl, [sp, #16]                                 <== NOT EXECUTED
   2077c:	e58db014 	str	fp, [sp, #20]                                 <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
  rtems_blkdev_bnum disk_end = 0;                                     
   20780:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
  if (format == NULL || pt == NULL || dist == NULL) {                 
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
   20784:	eb000163 	bl	20d18 <rtems_bdpart_get_disk_data>             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   20788:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   2078c:	01a03007 	moveq	r3, r7                                      <== NOT EXECUTED
   20790:	01a0b007 	moveq	fp, r7                                      <== NOT EXECUTED
   20794:	0a000007 	beq	207b8 <rtems_bdpart_create+0xbc>              <== NOT EXECUTED
   20798:	ea000054 	b	208f0 <rtems_bdpart_create+0x1f4>               <== NOT EXECUTED
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
    unsigned prev_sum = dist_sum;                                     
                                                                      
    dist_sum += dist [i];                                             
   2079c:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
   207a0:	e79c2103 	ldr	r2, [ip, r3, lsl #2]                          <== NOT EXECUTED
                                                                      
    if (dist_sum < prev_sum) {                                        
   207a4:	e09bb002 	adds	fp, fp, r2                                   <== NOT EXECUTED
   207a8:	2a00004f 	bcs	208ec <rtems_bdpart_create+0x1f0>             <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
   207ac:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   207b0:	0a00004d 	beq	208ec <rtems_bdpart_create+0x1f0>             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
   207b4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   207b8:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
   207bc:	3afffff6 	bcc	2079c <rtems_bdpart_create+0xa0>              <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
   207c0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   207c4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   207c8:	13a07018 	movne	r7, #24                                     <== NOT EXECUTED
   207cc:	1a000047 	bne	208f0 <rtems_bdpart_create+0x1f4>             <== NOT EXECUTED
    return RTEMS_NOT_IMPLEMENTED;                                     
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
   207d0:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   207d4:	0a000005 	beq	207f0 <rtems_bdpart_create+0xf4>              <== NOT EXECUTED
    disk_end -= (disk_end % record_space);                            
   207d8:	e59d4018 	ldr	r4, [sp, #24]                                 <== NOT EXECUTED
   207dc:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   207e0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   207e4:	eb00d217 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   207e8:	e0600004 	rsb	r0, r0, r4                                    <== NOT EXECUTED
   207ec:	e58d0018 	str	r0, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * In case we need an extended partition and logical partitions we have to
   * account for the space of each EBR.                               
   */                                                                 
  if (count > 4) {                                                    
   207f0:	e3550004 	cmp	r5, #4                                        <== NOT EXECUTED
    overhead += (count - 3) * record_space;                           
   207f4:	82453003 	subhi	r3, r5, #3                                  <== NOT EXECUTED
   207f8:	802c6693 	mlahi	ip, r3, r6, r6                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   * In case we need an extended partition and logical partitions we have to
   * account for the space of each EBR.                               
   */                                                                 
  if (count > 4) {                                                    
   207fc:	91a0c006 	movls	ip, r6                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Account space to align every partition on cylinder boundaries if 
   * necessary.                                                       
   */                                                                 
  if (dos_compatibility) {                                            
   20800:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
    overhead += (count - 1) * record_space;                           
   20804:	12453001 	subne	r3, r5, #1                                  <== NOT EXECUTED
   20808:	102cc693 	mlane	ip, r3, r6, ip                              <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Check disk space */                                              
  if ((overhead + count) > disk_end) {                                
   2080c:	e59d9018 	ldr	r9, [sp, #24]                                 <== NOT EXECUTED
   20810:	e08c3005 	add	r3, ip, r5                                    <== NOT EXECUTED
   20814:	e1530009 	cmp	r3, r9                                        <== NOT EXECUTED
   20818:	83a0701b 	movhi	r7, #27                                     <== NOT EXECUTED
   2081c:	8a000033 	bhi	208f0 <rtems_bdpart_create+0x1f4>             <== NOT EXECUTED
                                                                      
  /* Begin of first primary partition */                              
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
   20820:	e06cc009 	rsb	ip, ip, r9                                    <== NOT EXECUTED
   20824:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   20828:	e59d8004 	ldr	r8, [sp, #4]                                  <== NOT EXECUTED
   2082c:	e1a09007 	mov	r9, r7                                        <== NOT EXECUTED
   20830:	e1a0a006 	mov	sl, r6                                        <== NOT EXECUTED
   20834:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   20838:	e1a0700c 	mov	r7, ip                                        <== NOT EXECUTED
                                                                      
  for (i = 0; i < count; ++i) {                                       
   2083c:	ea00001b 	b	208b0 <rtems_bdpart_create+0x1b4>               <== NOT EXECUTED
    rtems_bdpart_partition *p = pt + i;                               
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
   20840:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   20844:	e793c104 	ldr	ip, [r3, r4, lsl #2]                          <== NOT EXECUTED
   20848:	e003079c 	mul	r3, ip, r7                                    <== NOT EXECUTED
    if (s < free_space || s < dist [i]) {                             
   2084c:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
      /* TODO: Calculate without overflow */                          
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
   20850:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
  for (i = 0; i < count; ++i) {                                       
    rtems_bdpart_partition *p = pt + i;                               
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
    if (s < free_space || s < dist [i]) {                             
   20854:	3a000024 	bcc	208ec <rtems_bdpart_create+0x1f0>             <== NOT EXECUTED
   20858:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   2085c:	3a000022 	bcc	208ec <rtems_bdpart_create+0x1f0>             <== NOT EXECUTED
      /* TODO: Calculate without overflow */                          
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
   20860:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
   20864:	eb00d163 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
    /* Ensure that the partition is not empty */                      
    if (s == 0) {                                                     
   20868:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   2086c:	11a03000 	movne	r3, r0                                      <== NOT EXECUTED
   20870:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
    pos += s;                                                         
   20874:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
   20878:	e588a000 	str	sl, [r8]                                      <== NOT EXECUTED
    pos += s;                                                         
   2087c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   20880:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   20884:	e08ca003 	add	sl, ip, r3                                    <== NOT EXECUTED
   20888:	eb00d1ee 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
    p->end = pos;                                                     
                                                                      
    /* Reserve space for the EBR if necessary */                      
    if (count > 4 && i > 2) {                                         
   2088c:	e3540002 	cmp	r4, #2                                        <== NOT EXECUTED
   20890:	83550004 	cmphi	r5, #4                                      <== NOT EXECUTED
      p->begin += record_space;                                       
   20894:	859d100c 	ldrhi	r1, [sp, #12]                               <== NOT EXECUTED
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
    pos += s;                                                         
   20898:	e060a00a 	rsb	sl, r0, sl                                    <== NOT EXECUTED
    p->end = pos;                                                     
                                                                      
    /* Reserve space for the EBR if necessary */                      
    if (count > 4 && i > 2) {                                         
   2089c:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
    s += record_space - (s % record_space);                           
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
    pos += s;                                                         
    p->end = pos;                                                     
   208a0:	e588a004 	str	sl, [r8, #4]                                  <== NOT EXECUTED
                                                                      
    /* Reserve space for the EBR if necessary */                      
    if (count > 4 && i > 2) {                                         
      p->begin += record_space;                                       
   208a4:	85881000 	strhi	r1, [r8]                                    <== NOT EXECUTED
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
   208a8:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
   208ac:	e2888030 	add	r8, r8, #48	; 0x30                            <== NOT EXECUTED
    if (s == 0) {                                                     
      s = 1;                                                          
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
   208b0:	e08a3006 	add	r3, sl, r6                                    <== NOT EXECUTED
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
   208b4:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
    rtems_blkdev_bnum s = free_space * dist [i];                      
    if (s < free_space || s < dist [i]) {                             
      /* TODO: Calculate without overflow */                          
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
   208b8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
    if (s == 0) {                                                     
      s = 1;                                                          
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
   208bc:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
   208c0:	3affffde 	bcc	20840 <rtems_bdpart_create+0x144>             <== NOT EXECUTED
      p->begin += record_space;                                       
    }                                                                 
  }                                                                   
                                                                      
  /* Expand the last partition to the disk end */                     
  pt [count - 1].end = disk_end;                                      
   208c4:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   208c8:	e1a07009 	mov	r7, r9                                        <== NOT EXECUTED
   208cc:	e2455001 	sub	r5, r5, #1                                    <== NOT EXECUTED
   208d0:	e1a09002 	mov	r9, r2                                        <== NOT EXECUTED
   208d4:	e3a02030 	mov	r2, #48	; 0x30                                <== NOT EXECUTED
   208d8:	e0233592 	mla	r3, r2, r5, r3                                <== NOT EXECUTED
   208dc:	e5839004 	str	r9, [r3, #4]                                  <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
   208e0:	ea000002 	b	208f0 <rtems_bdpart_create+0x1f4>               <== NOT EXECUTED
   208e4:	e3a07009 	mov	r7, #9                                        <== NOT EXECUTED
   208e8:	ea000000 	b	208f0 <rtems_bdpart_create+0x1f4>               <== NOT EXECUTED
   208ec:	e3a0700a 	mov	r7, #10                                       <== NOT EXECUTED
}                                                                     
   208f0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   208f4:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
   208f8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

000208fc <rtems_bdpart_dump>: { uuid_unparse_lower( type, str); } void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count) {
   208fc:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
   20900:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   20904:	e24dd038 	sub	sp, sp, #56	; 0x38                            <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  printf(                                                             
   20908:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
   2090c:	e59f00e0 	ldr	r0, [pc, #224]	; 209f4 <rtems_bdpart_dump+0xf8><== NOT EXECUTED
{                                                                     
  uuid_unparse_lower( type, str);                                     
}                                                                     
                                                                      
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{                                                                     
   20910:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
                                                                      
  for (i = 0; i < count; ++i) {                                       
    const rtems_bdpart_partition *p = pt + i;                         
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
   20914:	e1a08006 	mov	r8, r6                                        <== NOT EXECUTED
                                                                      
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  printf(                                                             
   20918:	eb00837b 	bl	4170c <puts>                                   <== NOT EXECUTED
    const rtems_bdpart_partition *p = pt + i;                         
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
   2091c:	e28da037 	add	sl, sp, #55	; 0x37                            <== NOT EXECUTED
static void rtems_bdpart_type_to_string(                              
  const uuid_t type,                                                  
  char str [37]                                                       
)                                                                     
{                                                                     
  uuid_unparse_lower( type, str);                                     
   20920:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
   20924:	ea00002c 	b	209dc <rtems_bdpart_dump+0xe0>                  <== NOT EXECUTED
    const rtems_bdpart_partition *p = pt + i;                         
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
   20928:	e2849008 	add	r9, r4, #8                                    <== NOT EXECUTED
   2092c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   20930:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
                                                                      
  for (i = 0; i < count; ++i) {                                       
    const rtems_bdpart_partition *p = pt + i;                         
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
   20934:	e5cd8037 	strb	r8, [sp, #55]	; 0x37                         <== NOT EXECUTED
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
   20938:	eb000115 	bl	20d94 <rtems_bdpart_to_mbr_partition_type>     <== NOT EXECUTED
   2093c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20940:	0a00001c 	beq	209b8 <rtems_bdpart_dump+0xbc>                <== NOT EXECUTED
      switch (type_mbr) {                                             
   20944:	e5dd3037 	ldrb	r3, [sp, #55]	; 0x37                         <== NOT EXECUTED
   20948:	e353000b 	cmp	r3, #11                                       <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
          break;                                                      
   2094c:	059f30a4 	ldreq	r3, [pc, #164]	; 209f8 <rtems_bdpart_dump+0xfc><== NOT EXECUTED
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
      switch (type_mbr) {                                             
   20950:	0a00001c 	beq	209c8 <rtems_bdpart_dump+0xcc>                <== NOT EXECUTED
   20954:	8a000005 	bhi	20970 <rtems_bdpart_dump+0x74>                <== NOT EXECUTED
   20958:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   2095c:	059f3098 	ldreq	r3, [pc, #152]	; 209fc <rtems_bdpart_dump+0x100><== NOT EXECUTED
   20960:	0a000018 	beq	209c8 <rtems_bdpart_dump+0xcc>                <== NOT EXECUTED
   20964:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
   20968:	1a00000d 	bne	209a4 <rtems_bdpart_dump+0xa8>                <== NOT EXECUTED
   2096c:	ea000008 	b	20994 <rtems_bdpart_dump+0x98>                  <== NOT EXECUTED
   20970:	e353000e 	cmp	r3, #14                                       <== NOT EXECUTED
   20974:	059f3084 	ldreq	r3, [pc, #132]	; 20a00 <rtems_bdpart_dump+0x104><== NOT EXECUTED
   20978:	0a000012 	beq	209c8 <rtems_bdpart_dump+0xcc>                <== NOT EXECUTED
   2097c:	e35300da 	cmp	r3, #218	; 0xda                               <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
   20980:	059f307c 	ldreq	r3, [pc, #124]	; 20a04 <rtems_bdpart_dump+0x108><== NOT EXECUTED
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
      switch (type_mbr) {                                             
   20984:	0a00000f 	beq	209c8 <rtems_bdpart_dump+0xcc>                <== NOT EXECUTED
   20988:	e353000c 	cmp	r3, #12                                       <== NOT EXECUTED
   2098c:	1a000004 	bne	209a4 <rtems_bdpart_dump+0xa8>                <== NOT EXECUTED
   20990:	ea000001 	b	2099c <rtems_bdpart_dump+0xa0>                  <== NOT EXECUTED
   20994:	e59f306c 	ldr	r3, [pc, #108]	; 20a08 <rtems_bdpart_dump+0x10c><== NOT EXECUTED
   20998:	ea00000a 	b	209c8 <rtems_bdpart_dump+0xcc>                  <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
   2099c:	e59f3068 	ldr	r3, [pc, #104]	; 20a0c <rtems_bdpart_dump+0x110><== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
   209a0:	ea000008 	b	209c8 <rtems_bdpart_dump+0xcc>                  <== NOT EXECUTED
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
   209a4:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
   209a8:	e3a01034 	mov	r1, #52	; 0x34                                <== NOT EXECUTED
   209ac:	e59f205c 	ldr	r2, [pc, #92]	; 20a10 <rtems_bdpart_dump+0x114><== NOT EXECUTED
   209b0:	eb00883d 	bl	42aac <snprintf>                               <== NOT EXECUTED
   209b4:	ea000002 	b	209c4 <rtems_bdpart_dump+0xc8>                  <== NOT EXECUTED
static void rtems_bdpart_type_to_string(                              
  const uuid_t type,                                                  
  char str [37]                                                       
)                                                                     
{                                                                     
  uuid_unparse_lower( type, str);                                     
   209b8:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   209bc:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   209c0:	eb006159 	bl	38f2c <uuid_unparse_lower>                     <== NOT EXECUTED
   209c4:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
   209c8:	e8940006 	ldm	r4, {r1, r2}                                  <== NOT EXECUTED
   209cc:	e59f0040 	ldr	r0, [pc, #64]	; 20a14 <rtems_bdpart_dump+0x118><== NOT EXECUTED
   209d0:	eb0082a8 	bl	41478 <printf>                                 <== NOT EXECUTED
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
   209d4:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   209d8:	e2844030 	add	r4, r4, #48	; 0x30                            <== NOT EXECUTED
   209dc:	e1560007 	cmp	r6, r7                                        <== NOT EXECUTED
   209e0:	3affffd0 	bcc	20928 <rtems_bdpart_dump+0x2c>                <== NOT EXECUTED
      p->end,                                                         
      type                                                            
    );                                                                
  }                                                                   
                                                                      
  puts( "------------+------------+-----------------------------------------------------");
   209e4:	e59f002c 	ldr	r0, [pc, #44]	; 20a18 <rtems_bdpart_dump+0x11c><== NOT EXECUTED
   209e8:	eb008347 	bl	4170c <puts>                                   <== NOT EXECUTED
}                                                                     
   209ec:	e28dd038 	add	sp, sp, #56	; 0x38                            <== NOT EXECUTED
   209f0:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

00020d18 <rtems_bdpart_get_disk_data>: rtems_status_code rtems_bdpart_get_disk_data( const char *disk_name, dev_t *disk, rtems_blkdev_bnum *disk_end ) {
   20d18:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   20d1c:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
   20d20:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  rtems_blkdev_bnum block_size = 0;                                   
  rtems_disk_device *dd = NULL;                                       
  struct stat st;                                                     
                                                                      
  /* Get disk handle */                                               
  rv = stat( disk_name, &st);                                         
   20d24:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
rtems_status_code rtems_bdpart_get_disk_data(                         
  const char *disk_name,                                              
  dev_t *disk,                                                        
  rtems_blkdev_bnum *disk_end                                         
)                                                                     
{                                                                     
   20d28:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  rtems_blkdev_bnum block_size = 0;                                   
  rtems_disk_device *dd = NULL;                                       
  struct stat st;                                                     
                                                                      
  /* Get disk handle */                                               
  rv = stat( disk_name, &st);                                         
   20d2c:	ebffa040 	bl	8e34 <stat>                                    <== NOT EXECUTED
  if (rv != 0) {                                                      
   20d30:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20d34:	1a000011 	bne	20d80 <rtems_bdpart_get_disk_data+0x68>       <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
  }                                                                   
  *disk = st.st_rdev;                                                 
   20d38:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   20d3c:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   20d40:	e8840003 	stm	r4, {r0, r1}                                  <== NOT EXECUTED
                                                                      
  /* Get disk begin, end and block size */                            
  dd = rtems_disk_obtain( *disk);                                     
   20d44:	ebff9554 	bl	629c <rtems_disk_obtain>                       <== NOT EXECUTED
  if (dd == NULL) {                                                   
   20d48:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   20d4c:	0a00000b 	beq	20d80 <rtems_bdpart_get_disk_data+0x68>       <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
  }                                                                   
  disk_begin = dd->start;                                             
  *disk_end = dd->size;                                               
   20d50:	e593201c 	ldr	r2, [r3, #28]                                 <== NOT EXECUTED
  /* Get disk begin, end and block size */                            
  dd = rtems_disk_obtain( *disk);                                     
  if (dd == NULL) {                                                   
    return RTEMS_INVALID_NAME;                                        
  }                                                                   
  disk_begin = dd->start;                                             
   20d54:	e5934018 	ldr	r4, [r3, #24]                                 <== NOT EXECUTED
  *disk_end = dd->size;                                               
   20d58:	e5852000 	str	r2, [r5]                                      <== NOT EXECUTED
  block_size = dd->block_size;                                        
   20d5c:	e5935020 	ldr	r5, [r3, #32]                                 <== NOT EXECUTED
  sc = rtems_disk_release( dd);                                       
   20d60:	ebff95c9 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   20d64:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20d68:	1a000007 	bne	20d8c <rtems_bdpart_get_disk_data+0x74>       <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* Check block size */                                              
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {                         
   20d6c:	e3550c02 	cmp	r5, #512	; 0x200                              <== NOT EXECUTED
   20d70:	3a000004 	bcc	20d88 <rtems_bdpart_get_disk_data+0x70>       <== NOT EXECUTED
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  /* Check that we have do not have a logical disk */                 
  if (disk_begin != 0) {                                              
   20d74:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   20d78:	0a000003 	beq	20d8c <rtems_bdpart_get_disk_data+0x74>       <== NOT EXECUTED
   20d7c:	ea000001 	b	20d88 <rtems_bdpart_get_disk_data+0x70>         <== NOT EXECUTED
   20d80:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
   20d84:	ea000000 	b	20d8c <rtems_bdpart_get_disk_data+0x74>         <== NOT EXECUTED
   20d88:	e3a0001b 	mov	r0, #27                                       <== NOT EXECUTED
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   20d8c:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
   20d90:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00020b24 <rtems_bdpart_mount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
   20b24:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
   20b28:	e3a0102f 	mov	r1, #47	; 0x2f                                <== NOT EXECUTED
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
   20b2c:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
   20b30:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   20b34:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
   20b38:	eb008f39 	bl	44824 <strrchr>                                <== NOT EXECUTED
   20b3c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  char *logical_disk_name = NULL;                                     
  char *logical_disk_marker = NULL;                                   
  char *mount_point = NULL;                                           
  char *mount_marker = NULL;                                          
  size_t disk_file_name_size = 0;                                     
  size_t disk_name_size = strlen( disk_name);                         
   20b40:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   20b44:	eb008bea 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   20b48:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
   20b4c:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   20b50:	eb008be7 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   20b54:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Create logical disk name base */                                 
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
   20b58:	e2860004 	add	r0, r6, #4                                    <== NOT EXECUTED
   20b5c:	ebff9c7b 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (logical_disk_name == NULL) {                                    
   20b60:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   20b64:	03a0601a 	moveq	r6, #26                                     <== NOT EXECUTED
   20b68:	0a000042 	beq	20c78 <rtems_bdpart_mount+0x154>              <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
   20b6c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   20b70:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   20b74:	eb008c7e 	bl	43d74 <strncpy>                                <== NOT EXECUTED
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
   20b78:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   20b7c:	01a08006 	moveq	r8, r6                                      <== NOT EXECUTED
   20b80:	0a000003 	beq	20b94 <rtems_bdpart_mount+0x70>               <== NOT EXECUTED
    disk_file_name += 1;                                              
   20b84:	e284a001 	add	sl, r4, #1                                    <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
   20b88:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   20b8c:	eb008bd8 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   20b90:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    disk_file_name = disk_name;                                       
    disk_file_name_size = disk_name_size;                             
  }                                                                   
                                                                      
  /* Create mount point base */                                       
  mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
   20b94:	e0889007 	add	r9, r8, r7                                    <== NOT EXECUTED
   20b98:	e2890005 	add	r0, r9, #5                                    <== NOT EXECUTED
   20b9c:	ebff9c6b 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (mount_point == NULL) {                                          
   20ba0:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   20ba4:	03a0601a 	moveq	r6, #26                                     <== NOT EXECUTED
   20ba8:	0a00002e 	beq	20c68 <rtems_bdpart_mount+0x144>              <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
   20bac:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   20bb0:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   20bb4:	eb008c6e 	bl	43d74 <strncpy>                                <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
   20bb8:	e2870001 	add	r0, r7, #1                                    <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
  mount_point [mount_base_size] = '/';                                
   20bbc:	e3a0302f 	mov	r3, #47	; 0x2f                                <== NOT EXECUTED
   20bc0:	e7c43007 	strb	r3, [r4, r7]                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
   20bc4:	e0840000 	add	r0, r4, r0                                    <== NOT EXECUTED
   20bc8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   20bcc:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
                                                                      
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
   20bd0:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
  mount_point [mount_base_size] = '/';                                
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
   20bd4:	eb008c66 	bl	43d74 <strncpy>                                <== NOT EXECUTED
                                                                      
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
   20bd8:	e0856006 	add	r6, r5, r6                                    <== NOT EXECUTED
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
   20bdc:	e0849009 	add	r9, r4, r9                                    <== NOT EXECUTED
   20be0:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
   20be4:	ea000016 	b	20c44 <rtems_bdpart_mount+0x120>                <== NOT EXECUTED
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
   20be8:	eb0087af 	bl	42aac <snprintf>                               <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
   20bec:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
   20bf0:	e3a02004 	mov	r2, #4                                        <== NOT EXECUTED
   20bf4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   20bf8:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
   20bfc:	c3a06003 	movgt	r6, #3                                      <== NOT EXECUTED
   20c00:	ca000018 	bgt	20c68 <rtems_bdpart_mount+0x144>              <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
   20c04:	eb008c5a 	bl	43d74 <strncpy>                                <== NOT EXECUTED
    rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);      
   20c08:	e59f1070 	ldr	r1, [pc, #112]	; 20c80 <rtems_bdpart_mount+0x15c><== NOT EXECUTED
   20c0c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20c10:	ebffa023 	bl	8ca4 <rtems_mkdir>                             <== NOT EXECUTED
    if (rv != 0) {                                                    
   20c14:	e250c000 	subs	ip, r0, #0                                   <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
   20c18:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   20c1c:	e59f2060 	ldr	r2, [pc, #96]	; 20c84 <rtems_bdpart_mount+0x160><== NOT EXECUTED
   20c20:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
   20c24:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
    rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);      
    if (rv != 0) {                                                    
   20c28:	13a0601b 	movne	r6, #27                                     <== NOT EXECUTED
   20c2c:	1a00000d 	bne	20c68 <rtems_bdpart_mount+0x144>              <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
   20c30:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   20c34:	ebff9d24 	bl	80cc <mount>                                   <== NOT EXECUTED
      mount_point,                                                    
      "msdos",                                                        
      0,                                                              
      NULL                                                            
    );                                                                
    if (rv != 0) {                                                    
   20c38:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      rmdir( mount_point);                                            
   20c3c:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   20c40:	1b0016f7 	blne	26824 <rmdir>                                <== NOT EXECUTED
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
   20c44:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   20c48:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
   20c4c:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   20c50:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
   20c54:	e59f202c 	ldr	r2, [pc, #44]	; 20c88 <rtems_bdpart_mount+0x164><== NOT EXECUTED
   20c58:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   20c5c:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
   20c60:	3affffe0 	bcc	20be8 <rtems_bdpart_mount+0xc4>               <== NOT EXECUTED
   20c64:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
   20c68:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   20c6c:	ebff9a90 	bl	76b4 <free>                                    <== NOT EXECUTED
  free( mount_point);                                                 
   20c70:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20c74:	ebff9a8e 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
   20c78:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   20c7c:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
                                                                      

0002111c <rtems_bdpart_new_record>: static rtems_status_code rtems_bdpart_new_record( dev_t disk, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
   2111c:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
   21120:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Synchronize previous block if necessary */                       
  if (*block != NULL) {                                               
   21124:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   21128:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
static rtems_status_code rtems_bdpart_new_record(                     
  dev_t disk,                                                         
  rtems_blkdev_bnum index,                                            
  rtems_bdbuf_buffer **block                                          
)                                                                     
{                                                                     
   2112c:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   21130:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   21134:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Synchronize previous block if necessary */                       
  if (*block != NULL) {                                               
   21138:	0a000003 	beq	2114c <rtems_bdpart_new_record+0x30>          <== NOT EXECUTED
    sc = rtems_bdbuf_sync( *block);                                   
   2113c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   21140:	ebff8e5d 	bl	4abc <rtems_bdbuf_sync>                        <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {                                     
   21144:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   21148:	1a000016 	bne	211a8 <rtems_bdpart_new_record+0x8c>          <== NOT EXECUTED
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the new record block (this accounts for disk block sizes > 512) */
  sc = rtems_bdbuf_read( disk, index, block);                         
   2114c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   21150:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   21154:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   21158:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   2115c:	ebff9061 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   21160:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   21164:	1a00000f 	bne	211a8 <rtems_bdpart_new_record+0x8c>          <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
   21168:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   2116c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   21170:	03a05009 	moveq	r5, #9                                      <== NOT EXECUTED
   21174:	0a00000b 	beq	211a8 <rtems_bdpart_new_record+0x8c>          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Clear record */                                                  
  memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);              
   21178:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   2117c:	e3a02c02 	mov	r2, #512	; 0x200                              <== NOT EXECUTED
   21180:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   21184:	eb007c94 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  /* Write signature */                                               
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =            
   21188:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   2118c:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   21190:	e3a02055 	mov	r2, #85	; 0x55                                <== NOT EXECUTED
   21194:	e5c321fe 	strb	r2, [r3, #510]	; 0x1fe                       <== NOT EXECUTED
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
   21198:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   2119c:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   211a0:	e3e02055 	mvn	r2, #85	; 0x55                                <== NOT EXECUTED
   211a4:	e5c321ff 	strb	r2, [r3, #511]	; 0x1ff                       <== NOT EXECUTED
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   211a8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   211ac:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00020eb0 <rtems_bdpart_read>: const char *disk_name, rtems_bdpart_format *format, rtems_bdpart_partition *pt, size_t *count ) {
   20eb0:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
   20eb4:	e2535000 	subs	r5, r3, #0                                   <== NOT EXECUTED
   20eb8:	15953000 	ldrne	r3, [r5]                                    <== NOT EXECUTED
  const char *disk_name,                                              
  rtems_bdpart_format *format,                                        
  rtems_bdpart_partition *pt,                                         
  size_t *count                                                       
)                                                                     
{                                                                     
   20ebc:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
   20ec0:	13a02030 	movne	r2, #48	; 0x30                              <== NOT EXECUTED
   20ec4:	10080392 	mulne	r8, r2, r3                                  <== NOT EXECUTED
   20ec8:	01a08005 	moveq	r8, r5                                      <== NOT EXECUTED
  dev_t disk = 0;                                                     
  size_t i = 0;                                                       
  const uint8_t *data = NULL;                                         
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || count == NULL) {                
   20ecc:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   20ed0:	13560000 	cmpne	r6, #0                                      <== NOT EXECUTED
  const char *disk_name,                                              
  rtems_bdpart_format *format,                                        
  rtems_bdpart_partition *pt,                                         
  size_t *count                                                       
)                                                                     
{                                                                     
   20ed4:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
   20ed8:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  dev_t disk = 0;                                                     
  size_t i = 0;                                                       
  const uint8_t *data = NULL;                                         
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || count == NULL) {                
   20edc:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   20ee0:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   20ee4:	0a000088 	beq	2110c <rtems_bdpart_read+0x25c>               <== NOT EXECUTED
   20ee8:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   20eec:	0a000086 	beq	2110c <rtems_bdpart_read+0x25c>               <== NOT EXECUTED
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
  rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */      
  rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */   
  rtems_blkdev_bnum disk_end = 0;                                     
   20ef0:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
  rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */      
   20ef4:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
   20ef8:	e246c030 	sub	ip, r6, #48	; 0x30                            <== NOT EXECUTED
  if (format == NULL || pt == NULL || count == NULL) {                
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Set count to a save value */                                     
  *count = 0;                                                         
   20efc:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
   20f00:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   20f04:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
  rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */      
  rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */   
  rtems_blkdev_bnum disk_end = 0;                                     
  dev_t disk = 0;                                                     
   20f08:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   20f0c:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   20f10:	e88d0c00 	stm	sp, {sl, fp}                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
   20f14:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
  size_t *count                                                       
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
   20f18:	e58d3014 	str	r3, [sp, #20]                                 <== NOT EXECUTED
                                                                      
  /* Set count to a save value */                                     
  *count = 0;                                                         
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
   20f1c:	ebffff7d 	bl	20d18 <rtems_bdpart_get_disk_data>             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   20f20:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20f24:	1a000079 	bne	21110 <rtems_bdpart_read+0x260>               <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* Read MBR */                                                      
  sc = rtems_bdpart_read_record( disk, 0, &block);                    
   20f28:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   20f2c:	e28d3014 	add	r3, sp, #20                                   <== NOT EXECUTED
   20f30:	e89d0003 	ldm	sp, {r0, r1}                                  <== NOT EXECUTED
   20f34:	ebffff54 	bl	20c8c <rtems_bdpart_read_record>               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   20f38:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   20f3c:	1a00006d 	bne	210f8 <rtems_bdpart_read+0x248>               <== NOT EXECUTED
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
   20f40:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
   20f44:	e593a020 	ldr	sl, [r3, #32]                                 <== NOT EXECUTED
   20f48:	e28a4f6f 	add	r4, sl, #444	; 0x1bc                          <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
   20f4c:	e0868008 	add	r8, r6, r8                                    <== NOT EXECUTED
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
   20f50:	e2844002 	add	r4, r4, #2                                    <== NOT EXECUTED
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);  
   20f54:	e28d9010 	add	r9, sp, #16                                   <== NOT EXECUTED
   20f58:	e28db00c 	add	fp, sp, #12                                   <== NOT EXECUTED
   20f5c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20f60:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   20f64:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   20f68:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
   20f6c:	ebffff98 	bl	20dd4 <rtems_bdpart_read_mbr_partition>        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   20f70:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20f74:	1a00002f 	bne	21038 <rtems_bdpart_read+0x188>               <== NOT EXECUTED
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Determine if we have a MBR or GPT format */                      
  if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {
   20f78:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   20f7c:	e5d33008 	ldrb	r3, [r3, #8]                                 <== NOT EXECUTED
   20f80:	e35300ee 	cmp	r3, #238	; 0xee                               <== NOT EXECUTED
   20f84:	03a04018 	moveq	r4, #24                                     <== NOT EXECUTED
   20f88:	0a00005a 	beq	210f8 <rtems_bdpart_read+0x248>               <== NOT EXECUTED
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
   20f8c:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
    esc = RTEMS_NOT_IMPLEMENTED;                                      
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
   20f90:	e5870000 	str	r0, [r7]                                      <== NOT EXECUTED
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
   20f94:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   20f98:	e5d321ba 	ldrb	r2, [r3, #442]	; 0x1ba                       <== NOT EXECUTED
   20f9c:	e5d301bb 	ldrb	r0, [r3, #443]	; 0x1bb                       <== NOT EXECUTED
   20fa0:	e5d311b9 	ldrb	r1, [r3, #441]	; 0x1b9                       <== NOT EXECUTED
   20fa4:	e0820400 	add	r0, r2, r0, lsl #8                            <== NOT EXECUTED
   20fa8:	e5d321b8 	ldrb	r2, [r3, #440]	; 0x1b8                       <== NOT EXECUTED
   20fac:	e0813400 	add	r3, r1, r0, lsl #8                            <== NOT EXECUTED
   20fb0:	e0823403 	add	r3, r2, r3, lsl #8                            <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
   20fb4:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   20fb8:	e5c72008 	strb	r2, [r7, #8]                                 <== NOT EXECUTED
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
   20fbc:	e5873004 	str	r3, [r7, #4]                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_read(                                  
   20fc0:	e28a7f7b 	add	r7, sl, #492	; 0x1ec                          <== NOT EXECUTED
   20fc4:	e2877002 	add	r7, r7, #2                                    <== NOT EXECUTED
                                                                      
  /* Iterate through the rest of the primary partition table */       
  for (i = 1; i < 4; ++i) {                                           
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
                                                                      
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
   20fc8:	e1a0a009 	mov	sl, r9                                        <== NOT EXECUTED
  );                                                                  
  format->mbr.dos_compatibility = true;                               
                                                                      
  /* Iterate through the rest of the primary partition table */       
  for (i = 1; i < 4; ++i) {                                           
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
   20fcc:	e2844010 	add	r4, r4, #16                                   <== NOT EXECUTED
                                                                      
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
   20fd0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20fd4:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   20fd8:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   20fdc:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
   20fe0:	ebffff7b 	bl	20dd4 <rtems_bdpart_read_mbr_partition>        <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {                                     
   20fe4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20fe8:	1a000012 	bne	21038 <rtems_bdpart_read+0x188>               <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
                                                                      
  /* Iterate through the rest of the primary partition table */       
  for (i = 1; i < 4; ++i) {                                           
   20fec:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
   20ff0:	1afffff5 	bne	20fcc <rtems_bdpart_read+0x11c>               <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
   20ff4:	e59d400c 	ldr	r4, [sp, #12]                                 <== NOT EXECUTED
  while (ebr != 0) {                                                  
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( disk, ebr, &block);                
   20ff8:	e28d7014 	add	r7, sp, #20                                   <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
  while (ebr != 0) {                                                  
   20ffc:	ea00002f 	b	210c0 <rtems_bdpart_read+0x210>                 <== NOT EXECUTED
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( disk, ebr, &block);                
   21000:	e89d0003 	ldm	sp, {r0, r1}                                  <== NOT EXECUTED
   21004:	ebffff20 	bl	20c8c <rtems_bdpart_read_record>               <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {                                     
   21008:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
   2100c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   21010:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   21014:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  while (ebr != 0) {                                                  
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( disk, ebr, &block);                
    if (sc != RTEMS_SUCCESSFUL) {                                     
   21018:	1a000006 	bne	21038 <rtems_bdpart_read+0x188>               <== NOT EXECUTED
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
   2101c:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
   21020:	e5900020 	ldr	r0, [r0, #32]                                 <== NOT EXECUTED
   21024:	e2800f6f 	add	r0, r0, #444	; 0x1bc                          <== NOT EXECUTED
   21028:	e2800002 	add	r0, r0, #2                                    <== NOT EXECUTED
   2102c:	ebffff68 	bl	20dd4 <rtems_bdpart_read_mbr_partition>        <== NOT EXECUTED
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                
      &p,                                                             
      p_end,                                                          
      NULL                                                            
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
   21030:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21034:	0a000001 	beq	21040 <rtems_bdpart_read+0x190>               <== NOT EXECUTED
   21038:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   2103c:	ea00002d 	b	210f8 <rtems_bdpart_read+0x248>                 <== NOT EXECUTED
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition begin */                                      
    tmp = p->begin + ebr;                                             
   21040:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   21044:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
   21048:	e0842001 	add	r2, r4, r1                                    <== NOT EXECUTED
    if (tmp > p->begin) {                                             
   2104c:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   21050:	9a000027 	bls	210f4 <rtems_bdpart_read+0x244>               <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
   21054:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
   21058:	e0844001 	add	r4, r4, r1                                    <== NOT EXECUTED
    if (tmp > p->end) {                                               
   2105c:	e1540001 	cmp	r4, r1                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Adjust partition begin */                                      
    tmp = p->begin + ebr;                                             
    if (tmp > p->begin) {                                             
      p->begin = tmp;                                                 
   21060:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
    if (tmp > p->end) {                                               
   21064:	9a000022 	bls	210f4 <rtems_bdpart_read+0x244>               <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
   21068:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   2106c:	e5922020 	ldr	r2, [r2, #32]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
    if (tmp > p->end) {                                               
      p->end = tmp;                                                   
   21070:	e5834004 	str	r4, [r3, #4]                                  <== NOT EXECUTED
}                                                                     
                                                                      
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)  
{                                                                     
  rtems_blkdev_bnum begin =                                           
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
   21074:	e2823f75 	add	r3, r2, #468	; 0x1d4                          <== NOT EXECUTED
   21078:	e2833002 	add	r3, r3, #2                                    <== NOT EXECUTED
   2107c:	e5d34003 	ldrb	r4, [r3, #3]                                 <== NOT EXECUTED
   21080:	e5d3c002 	ldrb	ip, [r3, #2]                                 <== NOT EXECUTED
   21084:	e5d30001 	ldrb	r0, [r3, #1]                                 <== NOT EXECUTED
  uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];                 
                                                                      
  if (type == RTEMS_BDPART_MBR_EXTENDED) {                            
   21088:	e5d211d2 	ldrb	r1, [r2, #466]	; 0x1d2                       <== NOT EXECUTED
   2108c:	e08c4404 	add	r4, ip, r4, lsl #8                            <== NOT EXECUTED
   21090:	e5d231d6 	ldrb	r3, [r2, #470]	; 0x1d6                       <== NOT EXECUTED
   21094:	e0804404 	add	r4, r0, r4, lsl #8                            <== NOT EXECUTED
   21098:	e3510005 	cmp	r1, #5                                        <== NOT EXECUTED
   2109c:	e0834404 	add	r4, r3, r4, lsl #8                            <== NOT EXECUTED
   210a0:	1a00000a 	bne	210d0 <rtems_bdpart_read+0x220>               <== NOT EXECUTED
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                 
    );                                                                
    if (ebr != 0) {                                                   
   210a4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   210a8:	0a000008 	beq	210d0 <rtems_bdpart_read+0x220>               <== NOT EXECUTED
      /* Adjust partition EBR block index */                          
      tmp = ebr + ep_begin;                                           
   210ac:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   210b0:	e0843003 	add	r3, r4, r3                                    <== NOT EXECUTED
      if (tmp > ebr) {                                                
   210b4:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
   210b8:	9a00000d 	bls	210f4 <rtems_bdpart_read+0x244>               <== NOT EXECUTED
   210bc:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
  while (ebr != 0) {                                                  
   210c0:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( disk, ebr, &block);                
   210c4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   210c8:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
  while (ebr != 0) {                                                  
   210cc:	1affffcb 	bne	21000 <rtems_bdpart_read+0x150>               <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
   210d0:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   210d4:	e59f203c 	ldr	r2, [pc, #60]	; 21118 <rtems_bdpart_read+0x268><== NOT EXECUTED
   210d8:	e0666003 	rsb	r6, r6, r3                                    <== NOT EXECUTED
   210dc:	e1a06246 	asr	r6, r6, #4                                    <== NOT EXECUTED
   210e0:	e0030692 	mul	r3, r2, r6                                    <== NOT EXECUTED
   210e4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   210e8:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
   210ec:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   210f0:	ea000000 	b	210f8 <rtems_bdpart_read+0x248>                 <== NOT EXECUTED
   210f4:	e3a0401b 	mov	r4, #27                                       <== NOT EXECUTED
                                                                      
cleanup:                                                              
                                                                      
  if (block != NULL) {                                                
   210f8:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
   210fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    rtems_bdbuf_release( block);                                      
   21100:	1bff8c38 	blne	41e8 <rtems_bdbuf_release>                   <== NOT EXECUTED
   21104:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   21108:	ea000000 	b	21110 <rtems_bdpart_read+0x260>                 <== NOT EXECUTED
   2110c:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
   21110:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
   21114:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00020dd4 <rtems_bdpart_read_mbr_partition>: const uint8_t *data, rtems_bdpart_partition **p, const rtems_bdpart_partition *p_end, rtems_blkdev_bnum *ep_begin ) {
   20dd4:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  rtems_blkdev_bnum begin =                                           
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
   20dd8:	e2805008 	add	r5, r0, #8                                    <== NOT EXECUTED
  const uint8_t *data,                                                
  rtems_bdpart_partition **p,                                         
  const rtems_bdpart_partition *p_end,                                
  rtems_blkdev_bnum *ep_begin                                         
)                                                                     
{                                                                     
   20ddc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_blkdev_bnum begin =                                           
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_blkdev_bnum size =                                            
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
   20de0:	e280000c 	add	r0, r0, #12                                   <== NOT EXECUTED
{                                                                     
  uint32_t value = 0;                                                 
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
   20de4:	e5d57003 	ldrb	r7, [r5, #3]                                 <== NOT EXECUTED
   20de8:	e5d08002 	ldrb	r8, [r0, #2]                                 <== NOT EXECUTED
   20dec:	e5d56002 	ldrb	r6, [r5, #2]                                 <== NOT EXECUTED
   20df0:	e5d0c003 	ldrb	ip, [r0, #3]                                 <== NOT EXECUTED
   20df4:	e5d5a001 	ldrb	sl, [r5, #1]                                 <== NOT EXECUTED
   20df8:	e5d09001 	ldrb	r9, [r0, #1]                                 <== NOT EXECUTED
  rtems_blkdev_bnum end = begin + size;                               
  uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];                 
   20dfc:	e5d45004 	ldrb	r5, [r4, #4]                                 <== NOT EXECUTED
   20e00:	e0866407 	add	r6, r6, r7, lsl #8                            <== NOT EXECUTED
   20e04:	e088c40c 	add	ip, r8, ip, lsl #8                            <== NOT EXECUTED
   20e08:	e5d40008 	ldrb	r0, [r4, #8]                                 <== NOT EXECUTED
   20e0c:	e5d4800c 	ldrb	r8, [r4, #12]                                <== NOT EXECUTED
   20e10:	e08a6406 	add	r6, sl, r6, lsl #8                            <== NOT EXECUTED
   20e14:	e089c40c 	add	ip, r9, ip, lsl #8                            <== NOT EXECUTED
                                                                      
  if (type == RTEMS_BDPART_MBR_EMPTY) {                               
   20e18:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   20e1c:	e0806406 	add	r6, r0, r6, lsl #8                            <== NOT EXECUTED
   20e20:	e088840c 	add	r8, r8, ip, lsl #8                            <== NOT EXECUTED
  const uint8_t *data,                                                
  rtems_bdpart_partition **p,                                         
  const rtems_bdpart_partition *p_end,                                
  rtems_blkdev_bnum *ep_begin                                         
)                                                                     
{                                                                     
   20e24:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  rtems_blkdev_bnum size =                                            
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  rtems_blkdev_bnum end = begin + size;                               
  uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];                 
                                                                      
  if (type == RTEMS_BDPART_MBR_EMPTY) {                               
   20e28:	0a00001e 	beq	20ea8 <rtems_bdpart_read_mbr_partition+0xd4>  <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
   20e2c:	e5910000 	ldr	r0, [r1]                                      <== NOT EXECUTED
   20e30:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
   20e34:	03a00005 	moveq	r0, #5                                      <== NOT EXECUTED
   20e38:	08bd87f0 	popeq	{r4, r5, r6, r7, r8, r9, sl, pc}            <== NOT EXECUTED
{                                                                     
  rtems_blkdev_bnum begin =                                           
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_blkdev_bnum size =                                            
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  rtems_blkdev_bnum end = begin + size;                               
   20e3c:	e0888006 	add	r8, r8, r6                                    <== NOT EXECUTED
                                                                      
  if (type == RTEMS_BDPART_MBR_EMPTY) {                               
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
    return RTEMS_TOO_MANY;                                            
  } else if (begin >= end) {                                          
   20e40:	e1560008 	cmp	r6, r8                                        <== NOT EXECUTED
   20e44:	23a0001b 	movcs	r0, #27                                     <== NOT EXECUTED
   20e48:	28bd87f0 	popcs	{r4, r5, r6, r7, r8, r9, sl, pc}            <== NOT EXECUTED
    return RTEMS_IO_ERROR;                                            
  } else if (type == RTEMS_BDPART_MBR_EXTENDED) {                     
   20e4c:	e3550005 	cmp	r5, #5                                        <== NOT EXECUTED
   20e50:	1a000003 	bne	20e64 <rtems_bdpart_read_mbr_partition+0x90>  <== NOT EXECUTED
    if (ep_begin != NULL) {                                           
   20e54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      *ep_begin = begin;                                              
   20e58:	15836000 	strne	r6, [r3]                                    <== NOT EXECUTED
  } else if (*p == p_end) {                                           
    return RTEMS_TOO_MANY;                                            
  } else if (begin >= end) {                                          
    return RTEMS_IO_ERROR;                                            
  } else if (type == RTEMS_BDPART_MBR_EXTENDED) {                     
    if (ep_begin != NULL) {                                           
   20e5c:	1a00000f 	bne	20ea0 <rtems_bdpart_read_mbr_partition+0xcc>  <== NOT EXECUTED
   20e60:	ea000010 	b	20ea8 <rtems_bdpart_read_mbr_partition+0xd4>    <== NOT EXECUTED
      *ep_begin = begin;                                              
    }                                                                 
  } else {                                                            
    /* Increment partition index */                                   
    ++(*p);                                                           
   20e64:	e2800030 	add	r0, r0, #48	; 0x30                            <== NOT EXECUTED
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
   20e68:	e3a02030 	mov	r2, #48	; 0x30                                <== NOT EXECUTED
    if (ep_begin != NULL) {                                           
      *ep_begin = begin;                                              
    }                                                                 
  } else {                                                            
    /* Increment partition index */                                   
    ++(*p);                                                           
   20e6c:	e5810000 	str	r0, [r1]                                      <== NOT EXECUTED
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
   20e70:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   20e74:	eb007d58 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
   20e78:	e5971000 	ldr	r1, [r7]                                      <== NOT EXECUTED
    (*p)->end = end;                                                  
    rtems_bdpart_to_partition_type( type, (*p)->type);                
   20e7c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
   20e80:	e8810140 	stm	r1, {r6, r8}                                  <== NOT EXECUTED
    (*p)->end = end;                                                  
    rtems_bdpart_to_partition_type( type, (*p)->type);                
   20e84:	e2811008 	add	r1, r1, #8                                    <== NOT EXECUTED
   20e88:	ebffffcb 	bl	20dbc <rtems_bdpart_to_partition_type>         <== NOT EXECUTED
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
   20e8c:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
   20e90:	e5d41000 	ldrb	r1, [r4]                                     <== NOT EXECUTED
   20e94:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   20e98:	e5831028 	str	r1, [r3, #40]	; 0x28                          <== NOT EXECUTED
   20e9c:	e583202c 	str	r2, [r3, #44]	; 0x2c                          <== NOT EXECUTED
   20ea0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   20ea4:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
   20ea8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   20eac:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

00020c8c <rtems_bdpart_read_record>: static rtems_status_code rtems_bdpart_read_record( dev_t disk, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
   20c8c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   20c90:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Release previous block if necessary */                           
  if (*block != NULL) {                                               
   20c94:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   20c98:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
static rtems_status_code rtems_bdpart_read_record(                    
  dev_t disk,                                                         
  rtems_blkdev_bnum index,                                            
  rtems_bdbuf_buffer **block                                          
)                                                                     
{                                                                     
   20c9c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   20ca0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   20ca4:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Release previous block if necessary */                           
  if (*block != NULL) {                                               
   20ca8:	0a000003 	beq	20cbc <rtems_bdpart_read_record+0x30>         <== NOT EXECUTED
    sc = rtems_bdbuf_release( *block);                                
   20cac:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   20cb0:	ebff8d4c 	bl	41e8 <rtems_bdbuf_release>                     <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {                                     
   20cb4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20cb8:	18bd80f0 	popne	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the record block */                                         
  sc = rtems_bdbuf_read( disk, index, block);                         
   20cbc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   20cc0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   20cc4:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   20cc8:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   20ccc:	ebff9185 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   20cd0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20cd4:	18bd80f0 	popne	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
   20cd8:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   20cdc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   20ce0:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
   20ce4:	08bd80f0 	popeq	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
   20ce8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
static bool rtems_bdpart_is_valid_record( const uint8_t *data)        
{                                                                     
  return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]                   
   20cec:	e5d321fe 	ldrb	r2, [r3, #510]	; 0x1fe                       <== NOT EXECUTED
   20cf0:	e3520055 	cmp	r2, #85	; 0x55                                <== NOT EXECUTED
   20cf4:	1a000003 	bne	20d08 <rtems_bdpart_read_record+0x7c>         <== NOT EXECUTED
   20cf8:	e5d301ff 	ldrb	r0, [r3, #511]	; 0x1ff                       <== NOT EXECUTED
   20cfc:	e35000aa 	cmp	r0, #170	; 0xaa                               <== NOT EXECUTED
   20d00:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
   20d04:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
  if ( *block == NULL ) {                                             
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
   20d08:	e31000ff 	tst	r0, #255	; 0xff                               <== NOT EXECUTED
   20d0c:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
   20d10:	03a0001b 	moveq	r0, #27                                     <== NOT EXECUTED
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   20d14:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00005658 <rtems_bdpart_register>: rtems_status_code rtems_bdpart_register( const char *disk_name, const rtems_bdpart_partition *pt, size_t count ) {
    5658:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
    565c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
rtems_status_code rtems_bdpart_register(                              
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
    5660:	e24dd02c 	sub	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
    5664:	e58d3028 	str	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
  dev_t disk = 0;                                                     
    5668:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    566c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    5670:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
    5674:	e58d4024 	str	r4, [sp, #36]	; 0x24                          <== NOT EXECUTED
rtems_status_code rtems_bdpart_register(                              
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
    5678:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    567c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    5680:	e1a0b002 	mov	fp, r2                                        <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                     
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  char *logical_disk_name = NULL;                                     
  char *logical_disk_marker = NULL;                                   
  size_t disk_name_size = strlen( disk_name);                         
    5684:	eb00f91a 	bl	43af4 <strlen>                                 <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
    5688:	e28d1020 	add	r1, sp, #32                                   <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                     
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  char *logical_disk_name = NULL;                                     
  char *logical_disk_marker = NULL;                                   
  size_t disk_name_size = strlen( disk_name);                         
    568c:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
    5690:	e28d2028 	add	r2, sp, #40	; 0x28                            <== NOT EXECUTED
    5694:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
    5698:	eb006d9e 	bl	20d18 <rtems_bdpart_get_disk_data>             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    569c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
    56a0:	1a000031 	bne	576c <rtems_bdpart_register+0x114>            <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
    56a4:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
                                                                      
  /* Create logical disk name */                                      
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
    56a8:	e2880004 	add	r0, r8, #4                                    <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
    56ac:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
    56b0:	e59d7024 	ldr	r7, [sp, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
  /* Create logical disk name */                                      
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
    56b4:	eb0009a5 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (logical_disk_name == NULL) {                                    
    56b8:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    56bc:	03a0401a 	moveq	r4, #26                                     <== NOT EXECUTED
    56c0:	0a000029 	beq	576c <rtems_bdpart_register+0x114>            <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
    56c4:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
    56c8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
    56cc:	eb00f9a8 	bl	43d74 <strncpy>                                <== NOT EXECUTED
  logical_disk_marker = logical_disk_name + disk_name_size;           
    56d0:	e0868008 	add	r8, r6, r8                                    <== NOT EXECUTED
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
    56d4:	ea000019 	b	5740 <rtems_bdpart_register+0xe8>               <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
    56d8:	e59d900c 	ldr	r9, [sp, #12]                                 <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
    56dc:	e58d701c 	str	r7, [sp, #28]                                 <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
    56e0:	e58d9018 	str	r9, [sp, #24]                                 <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
  return temp.device;                                                 
    56e4:	e28da018 	add	sl, sp, #24                                   <== NOT EXECUTED
    56e8:	e89a0600 	ldm	sl, {r9, sl}                                  <== NOT EXECUTED
    56ec:	e58d9010 	str	r9, [sp, #16]                                 <== NOT EXECUTED
    56f0:	e58da014 	str	sl, [sp, #20]                                 <== NOT EXECUTED
                                                                      
    /* Create a new device identifier */                              
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Set partition number for logical disk name */                  
    rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
    56f4:	eb00f4ec 	bl	42aac <snprintf>                               <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
    56f8:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
    56fc:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
    5700:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
    /* Create a new device identifier */                              
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Set partition number for logical disk name */                  
    rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
    5704:	c3a04003 	movgt	r4, #3                                      <== NOT EXECUTED
    5708:	ca000015 	bgt	5764 <rtems_bdpart_register+0x10c>            <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
    570c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
    5710:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    5714:	e595c004 	ldr	ip, [r5, #4]                                  <== NOT EXECUTED
    5718:	e063c00c 	rsb	ip, r3, ip                                    <== NOT EXECUTED
    571c:	e28d3020 	add	r3, sp, #32                                   <== NOT EXECUTED
    5720:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
    5724:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
    5728:	e58d6008 	str	r6, [sp, #8]                                  <== NOT EXECUTED
    572c:	eb0003d2 	bl	667c <rtems_disk_create_log>                   <== NOT EXECUTED
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      logical_disk_name                                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
    5730:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
    5734:	e2855030 	add	r5, r5, #48	; 0x30                            <== NOT EXECUTED
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      logical_disk_name                                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
    5738:	11a04000 	movne	r4, r0                                      <== NOT EXECUTED
    573c:	1a000008 	bne	5764 <rtems_bdpart_register+0x10c>            <== NOT EXECUTED
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
  logical_disk_marker = logical_disk_name + disk_name_size;           
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
    5740:	e154000b 	cmp	r4, fp                                        <== NOT EXECUTED
                                                                      
    /* Create a new device identifier */                              
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Set partition number for logical disk name */                  
    rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
    5744:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
  for (i = 0; i < count; ++i) {                                       
    const rtems_bdpart_partition *p = pt + i;                         
    int rv = 0;                                                       
                                                                      
    /* New minor number */                                            
    ++minor;                                                          
    5748:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
                                                                      
    /* Create a new device identifier */                              
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Set partition number for logical disk name */                  
    rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
    574c:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
    5750:	e59f2020 	ldr	r2, [pc, #32]	; 5778 <rtems_bdpart_register+0x120><== NOT EXECUTED
    5754:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    5758:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
  logical_disk_marker = logical_disk_name + disk_name_size;           
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
    575c:	3affffdd 	bcc	56d8 <rtems_bdpart_register+0x80>             <== NOT EXECUTED
    5760:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
    5764:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    5768:	eb0007d1 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
    576c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    5770:	e28dd02c 	add	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
    5774:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0000577c <rtems_bdpart_register_from_disk>: rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name) {
    577c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
    5780:	e24ddfc6 	sub	sp, sp, #792	; 0x318                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_bdpart_format format;                                         
  rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];     
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;                  
    5784:	e3a0c010 	mov	ip, #16                                       <== NOT EXECUTED
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
    5788:	e28d1c03 	add	r1, sp, #768	; 0x300                          <== NOT EXECUTED
    578c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
    5790:	e28d3fc5 	add	r3, sp, #788	; 0x314                          <== NOT EXECUTED
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_bdpart_format format;                                         
  rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];     
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;                  
    5794:	e58dc314 	str	ip, [sp, #788]	; 0x314                        <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{                                                                     
    5798:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  rtems_bdpart_format format;                                         
  rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];     
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;                  
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
    579c:	eb006dc3 	bl	20eb0 <rtems_bdpart_read>                      <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    57a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  rtems_bdpart_format format;                                         
  rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];     
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;                  
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
    57a4:	e1a0400d 	mov	r4, sp                                        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* Register partitions */                                           
  return rtems_bdpart_register( disk_name, pt, count);                
    57a8:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
    57ac:	01a0100d 	moveq	r1, sp                                      <== NOT EXECUTED
    57b0:	059d2314 	ldreq	r2, [sp, #788]	; 0x314                      <== NOT EXECUTED
    57b4:	0bffffa7 	bleq	5658 <rtems_bdpart_register>                 <== NOT EXECUTED
}                                                                     
    57b8:	e28ddfc6 	add	sp, sp, #792	; 0x318                          <== NOT EXECUTED
    57bc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00020d94 <rtems_bdpart_to_mbr_partition_type>: bool rtems_bdpart_to_mbr_partition_type( const uuid_t type, uint8_t *mbr_type ) {
   20d94:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  *mbr_type = rtems_bdpart_mbr_partition_type( type);                 
   20d98:	e4d03001 	ldrb	r3, [r0], #1                                 <== NOT EXECUTED
                                                                      
  return memcmp(                                                      
   20d9c:	e3a0200f 	mov	r2, #15                                       <== NOT EXECUTED
bool rtems_bdpart_to_mbr_partition_type(                              
  const uuid_t type,                                                  
  uint8_t *mbr_type                                                   
)                                                                     
{                                                                     
  *mbr_type = rtems_bdpart_mbr_partition_type( type);                 
   20da0:	e5c13000 	strb	r3, [r1]                                     <== NOT EXECUTED
                                                                      
  return memcmp(                                                      
   20da4:	e59f100c 	ldr	r1, [pc, #12]	; 20db8 <rtems_bdpart_to_mbr_partition_type+0x24><== NOT EXECUTED
   20da8:	eb007cda 	bl	40118 <memcmp>                                 <== NOT EXECUTED
    type + 1,                                                         
    RTEMS_BDPART_MBR_MASTER_TYPE + 1,                                 
    sizeof( uuid_t) - 1                                               
  ) == 0;                                                             
}                                                                     
   20dac:	e2700001 	rsbs	r0, r0, #1                                   <== NOT EXECUTED
   20db0:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
   20db4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00020dbc <rtems_bdpart_to_partition_type>: static const uuid_t RTEMS_BDPART_MBR_MASTER_TYPE = RTEMS_BDPART_MBR_PARTITION_TYPE( RTEMS_BDPART_MBR_EMPTY); void rtems_bdpart_to_partition_type( uint8_t mbr_type, uuid_t type) { type [0] = mbr_type;
   20dbc:	e4c10001 	strb	r0, [r1], #1                                 <== NOT EXECUTED
  memcpy( type + 1, RTEMS_BDPART_MBR_MASTER_TYPE + 1, sizeof( uuid_t) - 1);
   20dc0:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   20dc4:	e59f1004 	ldr	r1, [pc, #4]	; 20dd0 <rtems_bdpart_to_partition_type+0x14><== NOT EXECUTED
   20dc8:	e3a0200f 	mov	r2, #15                                       <== NOT EXECUTED
   20dcc:	ea007cfb 	b	401c0 <memcpy>                                  <== NOT EXECUTED
                                                                      

00020a1c <rtems_bdpart_unmount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
   20a1c:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
   20a20:	e3a0102f 	mov	r1, #47	; 0x2f                                <== NOT EXECUTED
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
   20a24:	e1a09003 	mov	r9, r3                                        <== NOT EXECUTED
   20a28:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   20a2c:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
   20a30:	eb008f7b 	bl	44824 <strrchr>                                <== NOT EXECUTED
   20a34:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
  char *mount_point = NULL;                                           
  char *mount_marker = NULL;                                          
  size_t disk_file_name_size = 0;                                     
  size_t disk_name_size = strlen( disk_name);                         
   20a38:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20a3c:	eb008c2c 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   20a40:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
   20a44:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   20a48:	eb008c29 	bl	43af4 <strlen>                                 <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
   20a4c:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
  const char *disk_file_name = strrchr( disk_name, '/');              
  char *mount_point = NULL;                                           
  char *mount_marker = NULL;                                          
  size_t disk_file_name_size = 0;                                     
  size_t disk_name_size = strlen( disk_name);                         
  size_t mount_base_size = strlen( mount_base);                       
   20a50:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
   20a54:	01a0a004 	moveq	sl, r4                                      <== NOT EXECUTED
   20a58:	0a000003 	beq	20a6c <rtems_bdpart_unmount+0x50>             <== NOT EXECUTED
    disk_file_name += 1;                                              
   20a5c:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
   20a60:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   20a64:	eb008c22 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   20a68:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    disk_file_name = disk_name;                                       
    disk_file_name_size = disk_name_size;                             
  }                                                                   
                                                                      
  /* Create mount point base */                                       
  mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
   20a6c:	e0887005 	add	r7, r8, r5                                    <== NOT EXECUTED
   20a70:	e2870005 	add	r0, r7, #5                                    <== NOT EXECUTED
   20a74:	ebff9cb5 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (mount_point == NULL) {                                          
   20a78:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   20a7c:	03a0501a 	moveq	r5, #26                                     <== NOT EXECUTED
   20a80:	0a000022 	beq	20b10 <rtems_bdpart_unmount+0xf4>             <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
   20a84:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   20a88:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   20a8c:	eb008cb8 	bl	43d74 <strncpy>                                <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
   20a90:	e2850001 	add	r0, r5, #1                                    <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
  mount_point [mount_base_size] = '/';                                
   20a94:	e3a0302f 	mov	r3, #47	; 0x2f                                <== NOT EXECUTED
   20a98:	e7c43005 	strb	r3, [r4, r5]                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
   20a9c:	e0840000 	add	r0, r4, r0                                    <== NOT EXECUTED
   20aa0:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   20aa4:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
   20aa8:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
  mount_point [mount_base_size] = '/';                                
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
   20aac:	eb008cb0 	bl	43d74 <strncpy>                                <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
   20ab0:	e0847007 	add	r7, r4, r7                                    <== NOT EXECUTED
   20ab4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
   20ab8:	ea00000c 	b	20af0 <rtems_bdpart_unmount+0xd4>               <== NOT EXECUTED
    /* Create mount point */                                          
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
   20abc:	eb0087fa 	bl	42aac <snprintf>                               <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
   20ac0:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Unmount */                                                     
    rv = unmount( mount_point);                                       
   20ac4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
    /* Create mount point */                                          
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
   20ac8:	c3a05003 	movgt	r5, #3                                      <== NOT EXECUTED
   20acc:	ca00000f 	bgt	20b10 <rtems_bdpart_unmount+0xf4>             <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Unmount */                                                     
    rv = unmount( mount_point);                                       
   20ad0:	eb00187a 	bl	26cc0 <unmount>                                <== NOT EXECUTED
    if (rv == 0) {                                                    
   20ad4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      /* Remove mount point */                                        
      rv = rmdir( mount_point);                                       
   20ad8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Unmount */                                                     
    rv = unmount( mount_point);                                       
    if (rv == 0) {                                                    
   20adc:	1a000003 	bne	20af0 <rtems_bdpart_unmount+0xd4>             <== NOT EXECUTED
      /* Remove mount point */                                        
      rv = rmdir( mount_point);                                       
   20ae0:	eb00174f 	bl	26824 <rmdir>                                  <== NOT EXECUTED
      if (rv != 0) {                                                  
   20ae4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20ae8:	13a0501b 	movne	r5, #27                                     <== NOT EXECUTED
   20aec:	1a000007 	bne	20b10 <rtems_bdpart_unmount+0xf4>             <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
   20af0:	e1550006 	cmp	r5, r6                                        <== NOT EXECUTED
    /* Create mount point */                                          
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
   20af4:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
   20af8:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
   20afc:	e59f201c 	ldr	r2, [pc, #28]	; 20b20 <rtems_bdpart_unmount+0x104><== NOT EXECUTED
   20b00:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   20b04:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
   20b08:	3affffeb 	bcc	20abc <rtems_bdpart_unmount+0xa0>             <== NOT EXECUTED
   20b0c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
   20b10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20b14:	ebff9ae6 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
   20b18:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   20b1c:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

000055dc <rtems_bdpart_unregister>: rtems_status_code rtems_bdpart_unregister( const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count ) {
    55dc:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
    55e0:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
    55e4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  dev_t disk = 0;                                                     
    55e8:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    55ec:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
rtems_status_code rtems_bdpart_unregister(                            
  const char *disk_name,                                              
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count                                                        
)                                                                     
{                                                                     
    55f0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
    55f4:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
    55f8:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
  dev_t disk = 0;                                                     
    55fc:	e58d5008 	str	r5, [sp, #8]                                  <== NOT EXECUTED
    5600:	e58d600c 	str	r6, [sp, #12]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
  rtems_blkdev_bnum disk_end = 0;                                     
    5604:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
    5608:	eb006dc2 	bl	20d18 <rtems_bdpart_get_disk_data>             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    560c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
    5610:	059d8008 	ldreq	r8, [sp, #8]                                <== NOT EXECUTED
    5614:	059d600c 	ldreq	r6, [sp, #12]                               <== NOT EXECUTED
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.device = device;                                               
  return temp.__overlay.minor;                                        
    5618:	01a05007 	moveq	r5, r7                                      <== NOT EXECUTED
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    561c:	0a000007 	beq	5640 <rtems_bdpart_unregister+0x64>           <== NOT EXECUTED
    5620:	ea000009 	b	564c <rtems_bdpart_unregister+0x70>             <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
    5624:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
    5628:	e58d6004 	str	r6, [sp, #4]                                  <== NOT EXECUTED
                                                                      
    /* Get the device identifier */                                   
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Delete logical disk */                                         
    sc = rtems_disk_delete( logical_disk);                            
    562c:	e89d0003 	ldm	sp, {r0, r1}                                  <== NOT EXECUTED
    5630:	eb000334 	bl	6308 <rtems_disk_delete>                       <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {                                     
    5634:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    5638:	1a000004 	bne	5650 <rtems_bdpart_unregister+0x74>           <== NOT EXECUTED
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
    563c:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    5640:	e1550004 	cmp	r5, r4                                        <== NOT EXECUTED
    /* New minor number */                                            
    ++minor;                                                          
    5644:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
    5648:	3afffff5 	bcc	5624 <rtems_bdpart_unregister+0x48>           <== NOT EXECUTED
    564c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    5650:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
    5654:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

000211b0 <rtems_bdpart_write>: const char *disk_name, const rtems_bdpart_format *format, const rtems_bdpart_partition *pt, size_t count ) {
   211b0:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
   211b4:	e2518000 	subs	r8, r1, #0                                   <== NOT EXECUTED
  const char *disk_name,                                              
  const rtems_bdpart_format *format,                                  
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
   211b8:	e24dd034 	sub	sp, sp, #52	; 0x34                            <== NOT EXECUTED
   211bc:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   211c0:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
   211c4:	0a000003 	beq	211d8 <rtems_bdpart_write+0x28>               <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
   211c8:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
   211cc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   211d0:	05d8a008 	ldrbeq	sl, [r8, #8]                               <== NOT EXECUTED
   211d4:	0a000000 	beq	211dc <rtems_bdpart_write+0x2c>               <== NOT EXECUTED
   211d8:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
   211dc:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   211e0:	13a0203f 	movne	r2, #63	; 0x3f                              <== NOT EXECUTED
   211e4:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
  size_t ppc = 0; /* Primary partition count */                       
  size_t i = 0;                                                       
  uint8_t *data = NULL;                                               
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
   211e8:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
   211ec:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   211f0:	e20aa0ff 	and	sl, sl, #255	; 0xff                           <== NOT EXECUTED
  size_t ppc = 0; /* Primary partition count */                       
  size_t i = 0;                                                       
  uint8_t *data = NULL;                                               
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
   211f4:	01a00006 	moveq	r0, r6                                      <== NOT EXECUTED
   211f8:	0a000120 	beq	21680 <rtems_bdpart_write+0x4d0>              <== NOT EXECUTED
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL) {                                 
   211fc:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   21200:	13550000 	cmpne	r5, #0                                      <== NOT EXECUTED
   21204:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   21208:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   2120c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
   21210:	0a00011a 	beq	21680 <rtems_bdpart_write+0x4d0>              <== NOT EXECUTED
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
  dev_t disk = 0;                                                     
   21214:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
  if (format == NULL || pt == NULL) {                                 
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
   21218:	e28d1020 	add	r1, sp, #32                                   <== NOT EXECUTED
   2121c:	e28d2028 	add	r2, sp, #40	; 0x28                            <== NOT EXECUTED
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum record_space =                                    
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;           
  dev_t disk = 0;                                                     
   21220:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   21224:	e58db020 	str	fp, [sp, #32]                                 <== NOT EXECUTED
   21228:	e58dc024 	str	ip, [sp, #36]	; 0x24                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
   2122c:	e58d302c 	str	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                     
   21230:	e58d3028 	str	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
  if (format == NULL || pt == NULL) {                                 
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);      
   21234:	ebfffeb7 	bl	20d18 <rtems_bdpart_get_disk_data>             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   21238:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   2123c:	1a00010f 	bne	21680 <rtems_bdpart_write+0x4d0>              <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
   21240:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   21244:	0a000005 	beq	21260 <rtems_bdpart_write+0xb0>               <== NOT EXECUTED
    disk_end -= (disk_end % record_space);                            
   21248:	e59d4028 	ldr	r4, [sp, #40]	; 0x28                          <== NOT EXECUTED
   2124c:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   21250:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   21254:	eb00cf7b 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   21258:	e0600004 	rsb	r0, r0, r4                                    <== NOT EXECUTED
   2125c:	e58d0028 	str	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
  /* Check that we have a consistent partition table */               
  for (i = 0; i < count; ++i) {                                       
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Check that begin and end are proper within the disk */         
    if (p->begin >= disk_end || p->end > disk_end) {                  
   21260:	e59d0028 	ldr	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
   21264:	e1a07005 	mov	r7, r5                                        <== NOT EXECUTED
   21268:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   2126c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   21270:	ea00000e 	b	212b0 <rtems_bdpart_write+0x100>                <== NOT EXECUTED
   21274:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
   21278:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
   2127c:	2a0000f6 	bcs	2165c <rtems_bdpart_write+0x4ac>              <== NOT EXECUTED
   21280:	e593c004 	ldr	ip, [r3, #4]                                  <== NOT EXECUTED
   21284:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
   21288:	8a0000f3 	bhi	2165c <rtems_bdpart_write+0x4ac>              <== NOT EXECUTED
      esc = RTEMS_INVALID_NUMBER;                                     
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check that begin and end are valid */                          
    if (p->begin >= p->end) {                                         
   2128c:	e151000c 	cmp	r1, ip                                        <== NOT EXECUTED
   21290:	2a0000f1 	bcs	2165c <rtems_bdpart_write+0x4ac>              <== NOT EXECUTED
      esc = RTEMS_INVALID_NUMBER;                                     
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check that partitions do not overlap */                        
    if (i > 0 && pt [i - 1].end > p->begin) {                         
   21294:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   21298:	0a000002 	beq	212a8 <rtems_bdpart_write+0xf8>               <== NOT EXECUTED
   2129c:	e513c02c 	ldr	ip, [r3, #-44]	; 0x2c                         <== NOT EXECUTED
   212a0:	e15c0001 	cmp	ip, r1                                        <== NOT EXECUTED
   212a4:	8a0000ec 	bhi	2165c <rtems_bdpart_write+0x4ac>              <== NOT EXECUTED
  if (dos_compatibility) {                                            
    disk_end -= (disk_end % record_space);                            
  }                                                                   
                                                                      
  /* Check that we have a consistent partition table */               
  for (i = 0; i < count; ++i) {                                       
   212a8:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   212ac:	e2833030 	add	r3, r3, #48	; 0x30                            <== NOT EXECUTED
   212b0:	e1520006 	cmp	r2, r6                                        <== NOT EXECUTED
   212b4:	3affffee 	bcc	21274 <rtems_bdpart_write+0xc4>               <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
   212b8:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
   212bc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   212c0:	13a04018 	movne	r4, #24                                     <== NOT EXECUTED
   212c4:	1a0000e9 	bne	21670 <rtems_bdpart_write+0x4c0>              <== NOT EXECUTED
   * Set primary partition count.  If we have more than four partitions we need
   * an extended partition which will contain the partitions of number four and
   * above as logical partitions.  If we have four or less partitions we can
   * use the primary partition table.                                 
   */                                                                 
  ppc = count <= 4 ? count : 3;                                       
   212c8:	e3560004 	cmp	r6, #4                                        <== NOT EXECUTED
   212cc:	91a04006 	movls	r4, r6                                      <== NOT EXECUTED
   212d0:	83a04003 	movhi	r4, #3                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Check that the first primary partition starts at head one and sector one
   * under the virtual one head and 63 sectors geometry if necessary. 
   */                                                                 
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
   212d4:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   212d8:	1a000009 	bne	21304 <rtems_bdpart_write+0x154>              <== NOT EXECUTED
   * The space for the EBR and maybe some space which is needed for DOS
   * compatibility resides between the partitions.  So there have to be gaps of
   * the appropriate size between the partitions.                     
   */                                                                 
  for (i = ppc; i < count; ++i) {                                     
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
   212dc:	e3a03030 	mov	r3, #48	; 0x30                                <== NOT EXECUTED
   212e0:	e00a0493 	mul	sl, r3, r4                                    <== NOT EXECUTED
   212e4:	e2441001 	sub	r1, r4, #1                                    <== NOT EXECUTED
   212e8:	e085c00a 	add	ip, r5, sl                                    <== NOT EXECUTED
   212ec:	e0225193 	mla	r2, r3, r1, r5                                <== NOT EXECUTED
   212f0:	e58da00c 	str	sl, [sp, #12]                                 <== NOT EXECUTED
   212f4:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   212f8:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
   212fc:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   21300:	ea00000b 	b	21334 <rtems_bdpart_write+0x184>                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Check that the first primary partition starts at head one and sector one
   * under the virtual one head and 63 sectors geometry if necessary. 
   */                                                                 
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
   21304:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   21308:	e353003f 	cmp	r3, #63	; 0x3f                                <== NOT EXECUTED
   2130c:	1a0000d2 	bne	2165c <rtems_bdpart_write+0x4ac>              <== NOT EXECUTED
   21310:	eafffff1 	b	212dc <rtems_bdpart_write+0x12c>                <== NOT EXECUTED
   * The space for the EBR and maybe some space which is needed for DOS
   * compatibility resides between the partitions.  So there have to be gaps of
   * the appropriate size between the partitions.                     
   */                                                                 
  for (i = ppc; i < count; ++i) {                                     
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
   21314:	e5920004 	ldr	r0, [r2, #4]                                  <== NOT EXECUTED
   21318:	e491c030 	ldr	ip, [r1], #48	; 0x30                          <== NOT EXECUTED
   2131c:	e59da004 	ldr	sl, [sp, #4]                                  <== NOT EXECUTED
   21320:	e060000c 	rsb	r0, r0, ip                                    <== NOT EXECUTED
   21324:	e150000a 	cmp	r0, sl                                        <== NOT EXECUTED
   21328:	e2822030 	add	r2, r2, #48	; 0x30                            <== NOT EXECUTED
   2132c:	3a0000ca 	bcc	2165c <rtems_bdpart_write+0x4ac>              <== NOT EXECUTED
   * Each logical partition is described via one EBR preceding the partition.
   * The space for the EBR and maybe some space which is needed for DOS
   * compatibility resides between the partitions.  So there have to be gaps of
   * the appropriate size between the partitions.                     
   */                                                                 
  for (i = ppc; i < count; ++i) {                                     
   21330:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   21334:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
   21338:	3afffff5 	bcc	21314 <rtems_bdpart_write+0x164>              <== NOT EXECUTED
   2133c:	e3a09000 	mov	r9, #0                                        <== NOT EXECUTED
   21340:	e1a0a005 	mov	sl, r5                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
    uint8_t type = 0;                                                 
   21344:	e1a0b009 	mov	fp, r9                                        <== NOT EXECUTED
                                                                      
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Check type */                                                  
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {       
   21348:	e28d3033 	add	r3, sp, #51	; 0x33                            <== NOT EXECUTED
   2134c:	ea00000d 	b	21388 <rtems_bdpart_write+0x1d8>                <== NOT EXECUTED
   21350:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
    uint8_t type = 0;                                                 
   21354:	e5cdb033 	strb	fp, [sp, #51]	; 0x33                         <== NOT EXECUTED
                                                                      
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Check type */                                                  
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {       
   21358:	ebfffe8d 	bl	20d94 <rtems_bdpart_to_mbr_partition_type>     <== NOT EXECUTED
   2135c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   21360:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   21364:	0a0000be 	beq	21664 <rtems_bdpart_write+0x4b4>              <== NOT EXECUTED
      esc =  RTEMS_INVALID_ID;                                        
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check flags */                                                 
    if (p->flags > 0xffU) {                                           
   21368:	e59a202c 	ldr	r2, [sl, #44]	; 0x2c                          <== NOT EXECUTED
   2136c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   21370:	e59a2028 	ldr	r2, [sl, #40]	; 0x28                          <== NOT EXECUTED
   21374:	e28aa030 	add	sl, sl, #48	; 0x30                            <== NOT EXECUTED
   21378:	1a0000b9 	bne	21664 <rtems_bdpart_write+0x4b4>              <== NOT EXECUTED
   2137c:	e35200ff 	cmp	r2, #255	; 0xff                               <== NOT EXECUTED
   21380:	8a0000b7 	bhi	21664 <rtems_bdpart_write+0x4b4>              <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
   21384:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
   21388:	e1590006 	cmp	r9, r6                                        <== NOT EXECUTED
    uint8_t type = 0;                                                 
                                                                      
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Check type */                                                  
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {       
   2138c:	e28a0008 	add	r0, sl, #8                                    <== NOT EXECUTED
   21390:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
   21394:	3affffed 	bcc	21350 <rtems_bdpart_write+0x1a0>              <== NOT EXECUTED
    /* Check ID */                                                    
    /* TODO */                                                        
  }                                                                   
                                                                      
  /* New MBR */                                                       
  sc = rtems_bdpart_new_record( disk, 0, &block);                     
   21398:	e28d1020 	add	r1, sp, #32                                   <== NOT EXECUTED
   2139c:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   213a0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   213a4:	e28d302c 	add	r3, sp, #44	; 0x2c                            <== NOT EXECUTED
   213a8:	ebffff5b 	bl	2111c <rtems_bdpart_new_record>                <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
   213ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   213b0:	1a000085 	bne	215cc <rtems_bdpart_write+0x41c>              <== NOT EXECUTED
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
   213b4:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   213b8:	e5982004 	ldr	r2, [r8, #4]                                  <== NOT EXECUTED
   213bc:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
    value >>= 8;                                                      
   213c0:	e1a01822 	lsr	r1, r2, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   213c4:	e1a08c22 	lsr	r8, r2, #24                                   <== NOT EXECUTED
    value >>= 8;                                                      
   213c8:	e1a0c422 	lsr	ip, r2, #8                                    <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   213cc:	e5c311ba 	strb	r1, [r3, #442]	; 0x1ba                       <== NOT EXECUTED
   213d0:	e5c381bb 	strb	r8, [r3, #443]	; 0x1bb                       <== NOT EXECUTED
   213d4:	e5c3c1b9 	strb	ip, [r3, #441]	; 0x1b9                       <== NOT EXECUTED
   213d8:	e5c321b8 	strb	r2, [r3, #440]	; 0x1b8                       <== NOT EXECUTED
    format->mbr.disk_id,                                              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
                                                                      
  /* Write primary partition table */                                 
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
   213dc:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   213e0:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   213e4:	e2831f6f 	add	r1, r3, #444	; 0x1bc                          <== NOT EXECUTED
   213e8:	e2811002 	add	r1, r1, #2                                    <== NOT EXECUTED
  for (i = 0; i < ppc; ++i) {                                         
   213ec:	ea00001e 	b	2146c <rtems_bdpart_write+0x2bc>                <== NOT EXECUTED
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Write partition entry */                                       
    rtems_bdpart_write_mbr_partition(                                 
   213f0:	e8971004 	ldm	r7, {r2, ip}                                  <== NOT EXECUTED
                                                                      
static inline uint8_t rtems_bdpart_mbr_partition_type(                
  const uuid_t type                                                   
)                                                                     
{                                                                     
  return type [0];                                                    
   213f4:	e5d78008 	ldrb	r8, [r7, #8]                                 <== NOT EXECUTED
      data,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      rtems_bdpart_mbr_partition_type( p->type),                      
      (uint8_t) p->flags                                              
   213f8:	e597a028 	ldr	sl, [r7, #40]	; 0x28                          <== NOT EXECUTED
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
  for (i = 0; i < ppc; ++i) {                                         
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Write partition entry */                                       
    rtems_bdpart_write_mbr_partition(                                 
   213fc:	e062c00c 	rsb	ip, r2, ip                                    <== NOT EXECUTED
   21400:	e58d8014 	str	r8, [sp, #20]                                 <== NOT EXECUTED
   21404:	e1a08c2c 	lsr	r8, ip, #24                                   <== NOT EXECUTED
      data,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      rtems_bdpart_mbr_partition_type( p->type),                      
      (uint8_t) p->flags                                              
   21408:	e58da01c 	str	sl, [sp, #28]                                 <== NOT EXECUTED
   2140c:	e58d8018 	str	r8, [sp, #24]                                 <== NOT EXECUTED
    value >>= 8;                                                      
   21410:	e1a0a822 	lsr	sl, r2, #16                                   <== NOT EXECUTED
   21414:	e1a0842c 	lsr	r8, ip, #8                                    <== NOT EXECUTED
   21418:	e1a09422 	lsr	r9, r2, #8                                    <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   2141c:	e1a0bc22 	lsr	fp, r2, #24                                   <== NOT EXECUTED
    value >>= 8;                                                      
   21420:	e58d8010 	str	r8, [sp, #16]                                 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   21424:	e5c391c7 	strb	r9, [r3, #455]	; 0x1c7                       <== NOT EXECUTED
   21428:	e5c3a1c8 	strb	sl, [r3, #456]	; 0x1c8                       <== NOT EXECUTED
   2142c:	e5c3b1c9 	strb	fp, [r3, #457]	; 0x1c9                       <== NOT EXECUTED
   21430:	e59da010 	ldr	sl, [sp, #16]                                 <== NOT EXECUTED
    value >>= 8;                                                      
   21434:	e1a0882c 	lsr	r8, ip, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   21438:	e5c3a1cb 	strb	sl, [r3, #459]	; 0x1cb                       <== NOT EXECUTED
   2143c:	e5c381cc 	strb	r8, [r3, #460]	; 0x1cc                       <== NOT EXECUTED
   21440:	e59d8018 	ldr	r8, [sp, #24]                                 <== NOT EXECUTED
   21444:	e5c381cd 	strb	r8, [r3, #461]	; 0x1cd                       <== NOT EXECUTED
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
   21448:	e59da014 	ldr	sl, [sp, #20]                                 <== NOT EXECUTED
   2144c:	e5c3a1c2 	strb	sl, [r3, #450]	; 0x1c2                       <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   21450:	e59d801c 	ldr	r8, [sp, #28]                                 <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
                                                                      
  /* Write primary partition table */                                 
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
  for (i = 0; i < ppc; ++i) {                                         
   21454:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   21458:	e5c381be 	strb	r8, [r3, #446]	; 0x1be                       <== NOT EXECUTED
   2145c:	e5c321c6 	strb	r2, [r3, #454]	; 0x1c6                       <== NOT EXECUTED
   21460:	e5c3c1ca 	strb	ip, [r3, #458]	; 0x1ca                       <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
                                                                      
  /* Write primary partition table */                                 
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
  for (i = 0; i < ppc; ++i) {                                         
   21464:	e2877030 	add	r7, r7, #48	; 0x30                            <== NOT EXECUTED
   21468:	e2833010 	add	r3, r3, #16                                   <== NOT EXECUTED
   2146c:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
   21470:	3affffde 	bcc	213f0 <rtems_bdpart_write+0x240>              <== NOT EXECUTED
                                                                      
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
  }                                                                   
                                                                      
  /* Write extended partition with logical partitions if necessary */ 
  if (ppc != count) {                                                 
   21474:	e1540006 	cmp	r4, r6                                        <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
                                                                      
  /* Write primary partition table */                                 
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
  for (i = 0; i < ppc; ++i) {                                         
   21478:	e0813204 	add	r3, r1, r4, lsl #4                            <== NOT EXECUTED
                                                                      
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
  }                                                                   
                                                                      
  /* Write extended partition with logical partitions if necessary */ 
  if (ppc != count) {                                                 
   2147c:	0a00007a 	beq	2166c <rtems_bdpart_write+0x4bc>              <== NOT EXECUTED
    rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ 
                                                                      
    /* Begin of extended partition */                                 
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;       
   21480:	e59da00c 	ldr	sl, [sp, #12]                                 <== NOT EXECUTED
   21484:	e59dc004 	ldr	ip, [sp, #4]                                  <== NOT EXECUTED
   21488:	e795700a 	ldr	r7, [r5, sl]                                  <== NOT EXECUTED
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
   2148c:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          <== NOT EXECUTED
  /* Write extended partition with logical partitions if necessary */ 
  if (ppc != count) {                                                 
    rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ 
                                                                      
    /* Begin of extended partition */                                 
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;       
   21490:	e06c7007 	rsb	r7, ip, r7                                    <== NOT EXECUTED
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
   21494:	e0672002 	rsb	r2, r7, r2                                    <== NOT EXECUTED
    value >>= 8;                                                      
   21498:	e1a05427 	lsr	r5, r7, #8                                    <== NOT EXECUTED
   2149c:	e58d5018 	str	r5, [sp, #24]                                 <== NOT EXECUTED
   214a0:	e1a05422 	lsr	r5, r2, #8                                    <== NOT EXECUTED
   214a4:	e58d5010 	str	r5, [sp, #16]                                 <== NOT EXECUTED
  uint32_t size,                                                      
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
   214a8:	e283c008 	add	ip, r3, #8                                    <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   214ac:	e1a00c22 	lsr	r0, r2, #24                                   <== NOT EXECUTED
    value >>= 8;                                                      
   214b0:	e1a05822 	lsr	r5, r2, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   214b4:	e1a09c27 	lsr	r9, r7, #24                                   <== NOT EXECUTED
   214b8:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
    value >>= 8;                                                      
   214bc:	e58d500c 	str	r5, [sp, #12]                                 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   214c0:	e5c37008 	strb	r7, [r3, #8]                                 <== NOT EXECUTED
   214c4:	e5cc9003 	strb	r9, [ip, #3]                                 <== NOT EXECUTED
   214c8:	e59d5018 	ldr	r5, [sp, #24]                                 <== NOT EXECUTED
    value >>= 8;                                                      
   214cc:	e1a0b827 	lsr	fp, r7, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   214d0:	e5cc5001 	strb	r5, [ip, #1]                                 <== NOT EXECUTED
   214d4:	e5ccb002 	strb	fp, [ip, #2]                                 <== NOT EXECUTED
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   214d8:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
   214dc:	e5c3200c 	strb	r2, [r3, #12]                                <== NOT EXECUTED
   214e0:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
   214e4:	e283000c 	add	r0, r3, #12                                   <== NOT EXECUTED
   214e8:	e5c02003 	strb	r2, [r0, #3]                                 <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   214ec:	e28c5004 	add	r5, ip, #4                                    <== NOT EXECUTED
   214f0:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
   214f4:	e5c0c001 	strb	ip, [r0, #1]                                 <== NOT EXECUTED
   214f8:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   214fc:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
   21500:	e3a0a005 	mov	sl, #5                                        <== NOT EXECUTED
   21504:	e5c02002 	strb	r2, [r0, #2]                                 <== NOT EXECUTED
   21508:	e5c3a004 	strb	sl, [r3, #4]                                 <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   2150c:	e7c18204 	strb	r8, [r1, r4, lsl #4]                         <== NOT EXECUTED
   21510:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
   21514:	ea00004d 	b	21650 <rtems_bdpart_write+0x4a0>                <== NOT EXECUTED
      const rtems_bdpart_partition *p = pt + i;                       
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
   21518:	e1580004 	cmp	r8, r4                                        <== NOT EXECUTED
   2151c:	9a000021 	bls	215a8 <rtems_bdpart_write+0x3f8>              <== NOT EXECUTED
        rtems_blkdev_bnum begin = p->begin - record_space;            
                                                                      
        rtems_bdpart_write_mbr_partition(                             
   21520:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
    for (i = ppc; i < count; ++i) {                                   
      const rtems_bdpart_partition *p = pt + i;                       
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
        rtems_blkdev_bnum begin = p->begin - record_space;            
   21524:	e59da004 	ldr	sl, [sp, #4]                                  <== NOT EXECUTED
   21528:	e5151004 	ldr	r1, [r5, #-4]                                 <== NOT EXECUTED
                                                                      
        rtems_bdpart_write_mbr_partition(                             
   2152c:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   21530:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          <== NOT EXECUTED
    for (i = ppc; i < count; ++i) {                                   
      const rtems_bdpart_partition *p = pt + i;                       
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
        rtems_blkdev_bnum begin = p->begin - record_space;            
   21534:	e06a1001 	rsb	r1, sl, r1                                    <== NOT EXECUTED
                                                                      
        rtems_bdpart_write_mbr_partition(                             
   21538:	e0612002 	rsb	r2, r1, r2                                    <== NOT EXECUTED
   2153c:	e283cf73 	add	ip, r3, #460	; 0x1cc                          <== NOT EXECUTED
   21540:	e0671001 	rsb	r1, r7, r1                                    <== NOT EXECUTED
   21544:	e1a0ec22 	lsr	lr, r2, #24                                   <== NOT EXECUTED
   21548:	e28cc002 	add	ip, ip, #2                                    <== NOT EXECUTED
   2154c:	e58de00c 	str	lr, [sp, #12]                                 <== NOT EXECUTED
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
   21550:	e28c000c 	add	r0, ip, #12                                   <== NOT EXECUTED
    value >>= 8;                                                      
   21554:	e1a0e422 	lsr	lr, r2, #8                                    <== NOT EXECUTED
  uint32_t size,                                                      
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
   21558:	e28cc008 	add	ip, ip, #8                                    <== NOT EXECUTED
   2155c:	e1a0a821 	lsr	sl, r1, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   21560:	e1a0bc21 	lsr	fp, r1, #24                                   <== NOT EXECUTED
    value >>= 8;                                                      
   21564:	e1a09421 	lsr	r9, r1, #8                                    <== NOT EXECUTED
   21568:	e58de008 	str	lr, [sp, #8]                                  <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   2156c:	e5c311d6 	strb	r1, [r3, #470]	; 0x1d6                       <== NOT EXECUTED
   21570:	e5ccb003 	strb	fp, [ip, #3]                                 <== NOT EXECUTED
   21574:	e5cc9001 	strb	r9, [ip, #1]                                 <== NOT EXECUTED
   21578:	e5cca002 	strb	sl, [ip, #2]                                 <== NOT EXECUTED
   2157c:	e5c321da 	strb	r2, [r3, #474]	; 0x1da                       <== NOT EXECUTED
    value >>= 8;                                                      
   21580:	e1a0e822 	lsr	lr, r2, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   21584:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   21588:	e5c02003 	strb	r2, [r0, #3]                                 <== NOT EXECUTED
   2158c:	e59da008 	ldr	sl, [sp, #8]                                  <== NOT EXECUTED
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   21590:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   21594:	e5c0e002 	strb	lr, [r0, #2]                                 <== NOT EXECUTED
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
   21598:	e3a0e005 	mov	lr, #5                                        <== NOT EXECUTED
   2159c:	e5c0a001 	strb	sl, [r0, #1]                                 <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   215a0:	e5c3c1ce 	strb	ip, [r3, #462]	; 0x1ce                       <== NOT EXECUTED
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
   215a4:	e5c3e1d2 	strb	lr, [r3, #466]	; 0x1d2                       <== NOT EXECUTED
        );                                                            
      }                                                               
                                                                      
      /* New EBR */                                                   
      ebr = p->begin - record_space;                                  
      sc = rtems_bdpart_new_record( disk, ebr, &block);               
   215a8:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
   215ac:	e5152004 	ldr	r2, [r5, #-4]                                 <== NOT EXECUTED
   215b0:	e28d302c 	add	r3, sp, #44	; 0x2c                            <== NOT EXECUTED
   215b4:	e0602002 	rsb	r2, r0, r2                                    <== NOT EXECUTED
   215b8:	e28d1020 	add	r1, sp, #32                                   <== NOT EXECUTED
   215bc:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   215c0:	ebfffed5 	bl	2111c <rtems_bdpart_new_record>                <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL) {                                   
   215c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   215c8:	0a000001 	beq	215d4 <rtems_bdpart_write+0x424>              <== NOT EXECUTED
   215cc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   215d0:	ea000026 	b	21670 <rtems_bdpart_write+0x4c0>                <== NOT EXECUTED
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
   215d4:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   215d8:	e5d50004 	ldrb	r0, [r5, #4]                                 <== NOT EXECUTED
   215dc:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   215e0:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
   215e4:	e2831f6f 	add	r1, r3, #444	; 0x1bc                          <== NOT EXECUTED
   215e8:	e595a000 	ldr	sl, [r5]                                      <== NOT EXECUTED
   215ec:	e515c004 	ldr	ip, [r5, #-4]                                 <== NOT EXECUTED
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,              
        record_space,                                                 
        p->end - p->begin,                                            
        rtems_bdpart_mbr_partition_type( p->type),                    
        (uint8_t) p->flags                                            
   215f0:	e595b024 	ldr	fp, [r5, #36]	; 0x24                          <== NOT EXECUTED
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
   215f4:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
      rtems_bdpart_write_mbr_partition(                               
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,              
        record_space,                                                 
        p->end - p->begin,                                            
        rtems_bdpart_mbr_partition_type( p->type),                    
        (uint8_t) p->flags                                            
   215f8:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
   215fc:	e2811002 	add	r1, r1, #2                                    <== NOT EXECUTED
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
   21600:	e2839004 	add	r9, r3, #4                                    <== NOT EXECUTED
   21604:	e5c201c6 	strb	r0, [r2, #454]	; 0x1c6                       <== NOT EXECUTED
   21608:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
   2160c:	e1520009 	cmp	r2, r9                                        <== NOT EXECUTED
    data [i] = (uint8_t) value;                                       
   21610:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
   21614:	1afffffa 	bne	21604 <rtems_bdpart_write+0x454>              <== NOT EXECUTED
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
   21618:	e06cc00a 	rsb	ip, ip, sl                                    <== NOT EXECUTED
  uint8_t type,                                                       
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
   2161c:	e281100c 	add	r1, r1, #12                                   <== NOT EXECUTED
    data [i] = (uint8_t) value;                                       
    value >>= 8;                                                      
   21620:	e1a0282c 	lsr	r2, ip, #16                                   <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   21624:	e1a0ac2c 	lsr	sl, ip, #24                                   <== NOT EXECUTED
    value >>= 8;                                                      
   21628:	e1a0042c 	lsr	r0, ip, #8                                    <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
    data [i] = (uint8_t) value;                                       
   2162c:	e5c3c1ca 	strb	ip, [r3, #458]	; 0x1ca                       <== NOT EXECUTED
   21630:	e5c1a003 	strb	sl, [r1, #3]                                 <== NOT EXECUTED
   21634:	e5c10001 	strb	r0, [r1, #1]                                 <== NOT EXECUTED
   21638:	e5c12002 	strb	r2, [r1, #2]                                 <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
   2163c:	e5c3b1be 	strb	fp, [r3, #446]	; 0x1be                       <== NOT EXECUTED
  uint8_t flags                                                       
)                                                                     
{                                                                     
  rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
   21640:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   21644:	e5c321c2 	strb	r2, [r3, #450]	; 0x1c2                       <== NOT EXECUTED
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
   21648:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   2164c:	e2855030 	add	r5, r5, #48	; 0x30                            <== NOT EXECUTED
   21650:	e1580006 	cmp	r8, r6                                        <== NOT EXECUTED
   21654:	3affffaf 	bcc	21518 <rtems_bdpart_write+0x368>              <== NOT EXECUTED
   21658:	ea000003 	b	2166c <rtems_bdpart_write+0x4bc>                <== NOT EXECUTED
   2165c:	e3a0400a 	mov	r4, #10                                       <== NOT EXECUTED
   21660:	ea000002 	b	21670 <rtems_bdpart_write+0x4c0>                <== NOT EXECUTED
   21664:	e3a04004 	mov	r4, #4                                        <== NOT EXECUTED
   21668:	ea000000 	b	21670 <rtems_bdpart_write+0x4c0>                <== NOT EXECUTED
   2166c:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  if (block != NULL) {                                                
   21670:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   21674:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    rtems_bdbuf_sync( block);                                         
   21678:	1bff8d0f 	blne	4abc <rtems_bdbuf_sync>                      <== NOT EXECUTED
   2167c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
   21680:	e28dd034 	add	sp, sp, #52	; 0x34                            <== NOT EXECUTED
   21684:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0000c008 <rtems_blkdev_generic_ioctl>: rtems_libio_ioctl_args_t *args = arg; rtems_libio_t *iop = args->iop; rtems_disk_device *dd = iop->data1; int rc; switch (args->command)
    c008:	e5921004 	ldr	r1, [r2, #4]                                  
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    rtems_libio_ioctl_args_t *args = arg;                             
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    c00c:	e5923000 	ldr	r3, [r2]                                      
rtems_device_driver                                                   
rtems_blkdev_generic_ioctl(                                           
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    c010:	e92d4010 	push	{r4, lr}                                     
    c014:	e1a04002 	mov	r4, r2                                        
    rtems_libio_ioctl_args_t *args = arg;                             
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    int rc;                                                           
                                                                      
    switch (args->command)                                            
    c018:	e59f20c0 	ldr	r2, [pc, #192]	; c0e0 <rtems_blkdev_generic_ioctl+0xd8>
    c01c:	e1510002 	cmp	r1, r2                                        
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    rtems_libio_ioctl_args_t *args = arg;                             
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    c020:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          
    int rc;                                                           
                                                                      
    switch (args->command)                                            
    c024:	0a000013 	beq	c078 <rtems_blkdev_generic_ioctl+0x70>        
    c028:	8a000006 	bhi	c048 <rtems_blkdev_generic_ioctl+0x40>        
    c02c:	e59f20b0 	ldr	r2, [pc, #176]	; c0e4 <rtems_blkdev_generic_ioctl+0xdc><== NOT EXECUTED
    c030:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    c034:	0a00001b 	beq	c0a8 <rtems_blkdev_generic_ioctl+0xa0>        <== NOT EXECUTED
    c038:	e59f20a8 	ldr	r2, [pc, #168]	; c0e8 <rtems_blkdev_generic_ioctl+0xe0><== NOT EXECUTED
    c03c:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    c040:	1a00001f 	bne	c0c4 <rtems_blkdev_generic_ioctl+0xbc>        <== NOT EXECUTED
    c044:	ea000009 	b	c070 <rtems_blkdev_generic_ioctl+0x68>          <== NOT EXECUTED
    c048:	e59f209c 	ldr	r2, [pc, #156]	; c0ec <rtems_blkdev_generic_ioctl+0xe4>
    c04c:	e1510002 	cmp	r1, r2                                        
    c050:	0a00000e 	beq	c090 <rtems_blkdev_generic_ioctl+0x88>        
    c054:	e59f2094 	ldr	r2, [pc, #148]	; c0f0 <rtems_blkdev_generic_ioctl+0xe8><== NOT EXECUTED
    c058:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    c05c:	0a000016 	beq	c0bc <rtems_blkdev_generic_ioctl+0xb4>        <== NOT EXECUTED
    c060:	e59f208c 	ldr	r2, [pc, #140]	; c0f4 <rtems_blkdev_generic_ioctl+0xec><== NOT EXECUTED
    c064:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
    c068:	1a000015 	bne	c0c4 <rtems_blkdev_generic_ioctl+0xbc>        <== NOT EXECUTED
    c06c:	ea00000b 	b	c0a0 <rtems_blkdev_generic_ioctl+0x98>          <== NOT EXECUTED
    {                                                                 
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *((uint32_t *) args->buffer) = dd->media_block_size;      
    c070:	e5932024 	ldr	r2, [r3, #36]	; 0x24                          <== NOT EXECUTED
    c074:	ea000000 	b	c07c <rtems_blkdev_generic_ioctl+0x74>          <== NOT EXECUTED
            args->ioctl_return = 0;                                   
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETBLKSIZE:                                  
            *((uint32_t *) args->buffer) = dd->block_size;            
    c078:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
    c07c:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
    c080:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
            args->ioctl_return = 0;                                   
    c084:	e3a03000 	mov	r3, #0                                        
    c088:	e584300c 	str	r3, [r4, #12]                                 
            break;                                                    
    c08c:	ea000011 	b	c0d8 <rtems_blkdev_generic_ioctl+0xd0>          
                                                                      
        case RTEMS_BLKIO_SETBLKSIZE:                                  
            dd->block_size = *((uint32_t *) args->buffer);            
    c090:	e5942008 	ldr	r2, [r4, #8]                                  
    c094:	e5922000 	ldr	r2, [r2]                                      
    c098:	e5832020 	str	r2, [r3, #32]                                 
    c09c:	eafffff8 	b	c084 <rtems_blkdev_generic_ioctl+0x7c>          
            args->ioctl_return = 0;                                   
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *((rtems_blkdev_bnum *) args->buffer) = dd->size;         
    c0a0:	e593201c 	ldr	r2, [r3, #28]                                 <== NOT EXECUTED
    c0a4:	eafffff4 	b	c07c <rtems_blkdev_generic_ioctl+0x74>          <== NOT EXECUTED
            args->ioctl_return = 0;                                   
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SYNCDEV:                                     
            rc = rtems_bdbuf_syncdev(dd->dev);                        
    c0a8:	e8930003 	ldm	r3, {r0, r1}                                  <== NOT EXECUTED
    c0ac:	ebfff814 	bl	a104 <rtems_bdbuf_syncdev>                     <== NOT EXECUTED
            args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
    c0b0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    c0b4:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
    c0b8:	ea000005 	b	c0d4 <rtems_blkdev_generic_ioctl+0xcc>          <== NOT EXECUTED
        case RTEMS_BLKIO_REQUEST:                                     
            /*                                                        
             * It is not allowed to directly access the driver circumventing
             * the cache.                                             
             */                                                       
            args->ioctl_return = (uint32_t) -1;                       
    c0bc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
    c0c0:	eafffff0 	b	c088 <rtems_blkdev_generic_ioctl+0x80>          <== NOT EXECUTED
            break;                                                    
                                                                      
        default:                                                      
            args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,   
    c0c4:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
    c0c8:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
    c0cc:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    c0d0:	e593f028 	ldr	pc, [r3, #40]	; 0x28                          <== NOT EXECUTED
    c0d4:	e584000c 	str	r0, [r4, #12]                                 <== NOT EXECUTED
                                                      args->buffer);  
            break;                                                    
    }                                                                 
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
    c0d8:	e3a00000 	mov	r0, #0                                        
    c0dc:	e8bd8010 	pop	{r4, pc}                                      
                                                                      

0000c230 <rtems_blkdev_generic_read>: void * arg) { rtems_status_code rc = RTEMS_SUCCESSFUL; rtems_libio_rw_args_t *args = arg; rtems_libio_t *iop = args->iop; rtems_disk_device *dd = iop->data1;
    c230:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
rtems_device_driver                                                   
rtems_blkdev_generic_read(                                            
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    c234:	e92d4ff7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
    rtems_libio_rw_args_t *args = arg;                                
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    c238:	e5938034 	ldr	r8, [r3, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c23c:	e9920c00 	ldmib	r2, {sl, fp}                                <== NOT EXECUTED
{                                                                     
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
    rtems_libio_rw_args_t *args = arg;                                
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    c240:	e5986020 	ldr	r6, [r8, #32]                                 <== NOT EXECUTED
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c244:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
rtems_device_driver                                                   
rtems_blkdev_generic_read(                                            
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    c248:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c24c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
    c250:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
    c254:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
    c258:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
    c25c:	eb003b9c 	bl	1b0d4 <__divdi3>                               <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    c260:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
    c264:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
    c268:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c26c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    c270:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
    c274:	eb003cc0 	bl	1b57c <__moddi3>                               <== NOT EXECUTED
    dev_t dev = dd->dev;                                              
    c278:	e898000c 	ldm	r8, {r2, r3}                                  <== NOT EXECUTED
                                                                      
    args->bytes_moved = 0;                                            
    c27c:	e5845018 	str	r5, [r4, #24]                                 <== NOT EXECUTED
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    c280:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
    dev_t dev = dd->dev;                                              
    c284:	e88d000c 	stm	sp, {r2, r3}                                  <== NOT EXECUTED
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
    rtems_libio_rw_args_t *args = arg;                                
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    c288:	e594800c 	ldr	r8, [r4, #12]                                 <== NOT EXECUTED
    uint32_t count = args->count;                                     
    c28c:	e5945010 	ldr	r5, [r4, #16]                                 <== NOT EXECUTED
    while (count > 0)                                                 
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dev, block, &diskbuf);                  
    c290:	e28db008 	add	fp, sp, #8                                    <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    dev_t dev = dd->dev;                                              
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
    c294:	ea000016 	b	c2f4 <rtems_blkdev_generic_read+0xc4>           <== NOT EXECUTED
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dev, block, &diskbuf);                  
    c298:	ebfffe7b 	bl	bc8c <rtems_bdbuf_read>                        <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
    c29c:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
            break;                                                    
        copy = block_size - blkofs;                                   
    c2a0:	e069a006 	rsb	sl, r9, r6                                    <== NOT EXECUTED
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
    c2a4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dev, block, &diskbuf);                  
        if (rc != RTEMS_SUCCESSFUL)                                   
    c2a8:	1a000017 	bne	c30c <rtems_blkdev_generic_read+0xdc>         <== NOT EXECUTED
            break;                                                    
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
    c2ac:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
    c2b0:	e5931020 	ldr	r1, [r3, #32]                                 <== NOT EXECUTED
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dev, block, &diskbuf);                  
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
        copy = block_size - blkofs;                                   
    c2b4:	e15a0005 	cmp	sl, r5                                        <== NOT EXECUTED
    c2b8:	21a0a005 	movcs	sl, r5                                      <== NOT EXECUTED
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
    c2bc:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
    c2c0:	e0811009 	add	r1, r1, r9                                    <== NOT EXECUTED
    c2c4:	eb00152f 	bl	11788 <memcpy>                                 <== NOT EXECUTED
        rc = rtems_bdbuf_release(diskbuf);                            
    c2c8:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
    c2cc:	ebfffa2e 	bl	ab8c <rtems_bdbuf_release>                     <== NOT EXECUTED
        args->bytes_moved += copy;                                    
    c2d0:	e5942018 	ldr	r2, [r4, #24]                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
    c2d4:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
        rc = rtems_bdbuf_release(diskbuf);                            
        args->bytes_moved += copy;                                    
    c2d8:	e082200a 	add	r2, r2, sl                                    <== NOT EXECUTED
    c2dc:	e5842018 	str	r2, [r4, #24]                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
    c2e0:	1a000009 	bne	c30c <rtems_blkdev_generic_read+0xdc>         <== NOT EXECUTED
            break;                                                    
        count -= copy;                                                
        buf += copy;                                                  
    c2e4:	e088800a 	add	r8, r8, sl                                    <== NOT EXECUTED
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
        rc = rtems_bdbuf_release(diskbuf);                            
        args->bytes_moved += copy;                                    
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
        count -= copy;                                                
    c2e8:	e06a5005 	rsb	r5, sl, r5                                    <== NOT EXECUTED
        buf += copy;                                                  
        blkofs = 0;                                                   
        block++;                                                      
    c2ec:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
    c2f0:	e1a09003 	mov	r9, r3                                        <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    dev_t dev = dd->dev;                                              
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
    c2f4:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dev, block, &diskbuf);                  
    c2f8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
    c2fc:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
    c300:	e89d0003 	ldm	sp, {r0, r1}                                  <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    dev_t dev = dd->dev;                                              
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
    c304:	1affffe3 	bne	c298 <rtems_blkdev_generic_read+0x68>         <== NOT EXECUTED
    c308:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
    c30c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
    c310:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
                                                                      

0000c130 <rtems_blkdev_generic_write>: void * arg) { rtems_status_code rc = RTEMS_SUCCESSFUL; rtems_libio_rw_args_t *args = arg; rtems_libio_t *iop = args->iop; rtems_disk_device *dd = iop->data1;
    c130:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
rtems_device_driver                                                   
rtems_blkdev_generic_write(                                           
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    c134:	e92d4ff7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
    rtems_libio_rw_args_t *args = arg;                                
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    c138:	e593a034 	ldr	sl, [r3, #52]	; 0x34                          <== NOT EXECUTED
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c13c:	e9920300 	ldmib	r2, {r8, r9}                                <== NOT EXECUTED
{                                                                     
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
    rtems_libio_rw_args_t *args = arg;                                
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    c140:	e59a6020 	ldr	r6, [sl, #32]                                 <== NOT EXECUTED
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c144:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
rtems_device_driver                                                   
rtems_blkdev_generic_write(                                           
    rtems_device_major_number major __attribute__((unused)),          
    rtems_device_minor_number minor __attribute__((unused)),          
    void                    * arg)                                    
{                                                                     
    c148:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c14c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
    c150:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    c154:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
    c158:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
    c15c:	eb003bdc 	bl	1b0d4 <__divdi3>                               <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    c160:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
    c164:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
    c168:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    c16c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    c170:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    c174:	eb003d00 	bl	1b57c <__moddi3>                               <== NOT EXECUTED
    dev_t dev = dd->dev;                                              
    c178:	e89a000c 	ldm	sl, {r2, r3}                                  <== NOT EXECUTED
                                                                      
    args->bytes_moved = 0;                                            
    c17c:	e5845018 	str	r5, [r4, #24]                                 <== NOT EXECUTED
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    c180:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    dev_t dev = dd->dev;                                              
    c184:	e88d000c 	stm	sp, {r2, r3}                                  <== NOT EXECUTED
    rtems_status_code rc = RTEMS_SUCCESSFUL;                          
    rtems_libio_rw_args_t *args = arg;                                
    rtems_libio_t *iop = args->iop;                                   
    rtems_disk_device *dd = iop->data1;                               
    uint32_t block_size = dd->block_size;                             
    char *buf = args->buffer;                                         
    c188:	e594900c 	ldr	r9, [r4, #12]                                 <== NOT EXECUTED
    uint32_t count = args->count;                                     
    c18c:	e5945010 	ldr	r5, [r4, #16]                                 <== NOT EXECUTED
    c190:	e28db008 	add	fp, sp, #8                                    <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    dev_t dev = dd->dev;                                              
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
    c194:	ea000021 	b	c220 <rtems_blkdev_generic_write+0xf0>          <== NOT EXECUTED
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
    c198:	e1550006 	cmp	r5, r6                                        <== NOT EXECUTED
    c19c:	23580000 	cmpcs	r8, #0                                      <== NOT EXECUTED
    c1a0:	1a000004 	bne	c1b8 <rtems_blkdev_generic_write+0x88>        <== NOT EXECUTED
            rc = rtems_bdbuf_get(dev, block, &diskbuf);               
    c1a4:	e89d0003 	ldm	sp, {r0, r1}                                  <== NOT EXECUTED
    c1a8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
    c1ac:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
    c1b0:	ebfffe82 	bl	bbc0 <rtems_bdbuf_get>                         <== NOT EXECUTED
    c1b4:	ea000003 	b	c1c8 <rtems_blkdev_generic_write+0x98>          <== NOT EXECUTED
        else                                                          
            rc = rtems_bdbuf_read(dev, block, &diskbuf);              
    c1b8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
    c1bc:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
    c1c0:	e89d0003 	ldm	sp, {r0, r1}                                  <== NOT EXECUTED
    c1c4:	ebfffeb0 	bl	bc8c <rtems_bdbuf_read>                        <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
    c1c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            break;                                                    
                                                                      
        copy = block_size - blkofs;                                   
    c1cc:	e068a006 	rsb	sl, r8, r6                                    <== NOT EXECUTED
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
    c1d0:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
            rc = rtems_bdbuf_get(dev, block, &diskbuf);               
        else                                                          
            rc = rtems_bdbuf_read(dev, block, &diskbuf);              
        if (rc != RTEMS_SUCCESSFUL)                                   
    c1d4:	1a000014 	bne	c22c <rtems_blkdev_generic_write+0xfc>        <== NOT EXECUTED
            break;                                                    
                                                                      
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
    c1d8:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
    c1dc:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
        else                                                          
            rc = rtems_bdbuf_read(dev, block, &diskbuf);              
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
                                                                      
        copy = block_size - blkofs;                                   
    c1e0:	e15a0005 	cmp	sl, r5                                        <== NOT EXECUTED
    c1e4:	21a0a005 	movcs	sl, r5                                      <== NOT EXECUTED
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
    c1e8:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
    c1ec:	e0800008 	add	r0, r0, r8                                    <== NOT EXECUTED
    c1f0:	eb001564 	bl	11788 <memcpy>                                 <== NOT EXECUTED
        args->bytes_moved += copy;                                    
    c1f4:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
    c1f8:	e083300a 	add	r3, r3, sl                                    <== NOT EXECUTED
    c1fc:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
    c200:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
    c204:	ebfffa3e 	bl	ab04 <rtems_bdbuf_release_modified>            <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
    c208:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    c20c:	1a000006 	bne	c22c <rtems_blkdev_generic_write+0xfc>        <== NOT EXECUTED
            break;                                                    
                                                                      
        count -= copy;                                                
        buf += copy;                                                  
    c210:	e089900a 	add	r9, r9, sl                                    <== NOT EXECUTED
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
                                                                      
        count -= copy;                                                
    c214:	e06a5005 	rsb	r5, sl, r5                                    <== NOT EXECUTED
        buf += copy;                                                  
        blkofs = 0;                                                   
        block++;                                                      
    c218:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
    c21c:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
    dev_t dev = dd->dev;                                              
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
    c220:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    c224:	1affffdb 	bne	c198 <rtems_blkdev_generic_write+0x68>        <== NOT EXECUTED
    c228:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
    c22c:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
                                                                      

0000bf80 <rtems_blkdev_ioctl>: rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) { size_t *arg_size = argp; int rc = 0; switch (req)
    bf80:	e59f3078 	ldr	r3, [pc, #120]	; c000 <rtems_blkdev_ioctl+0x80>
    bf84:	e1510003 	cmp	r1, r3                                        
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
                                                                      
int                                                                   
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    bf88:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
    size_t            *arg_size = argp;                               
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
    bf8c:	0a00000d 	beq	bfc8 <rtems_blkdev_ioctl+0x48>                
    bf90:	8a000003 	bhi	bfa4 <rtems_blkdev_ioctl+0x24>                
    bf94:	e2433001 	sub	r3, r3, #1                                    
    bf98:	e1510003 	cmp	r1, r3                                        
    bf9c:	1a000012 	bne	bfec <rtems_blkdev_ioctl+0x6c>                
    bfa0:	ea000006 	b	bfc0 <rtems_blkdev_ioctl+0x40>                  <== NOT EXECUTED
    bfa4:	e59f3058 	ldr	r3, [pc, #88]	; c004 <rtems_blkdev_ioctl+0x84><== NOT EXECUTED
    bfa8:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
    bfac:	0a00000a 	beq	bfdc <rtems_blkdev_ioctl+0x5c>                <== NOT EXECUTED
    bfb0:	e2433107 	sub	r3, r3, #-1073741823	; 0xc0000001             <== NOT EXECUTED
    bfb4:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
    bfb8:	1a00000b 	bne	bfec <rtems_blkdev_ioctl+0x6c>                <== NOT EXECUTED
    bfbc:	ea000003 	b	bfd0 <rtems_blkdev_ioctl+0x50>                  <== NOT EXECUTED
    {                                                                 
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *arg_size = dd->media_block_size;                         
    bfc0:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          <== NOT EXECUTED
    bfc4:	ea000005 	b	bfe0 <rtems_blkdev_ioctl+0x60>                  <== NOT EXECUTED
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETBLKSIZE:                                  
            *arg_size = dd->block_size;                               
    bfc8:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
    bfcc:	ea000003 	b	bfe0 <rtems_blkdev_ioctl+0x60>                  <== NOT EXECUTED
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SETBLKSIZE:                                  
            dd->block_size = *arg_size;                               
    bfd0:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
    bfd4:	e5803020 	str	r3, [r0, #32]                                 <== NOT EXECUTED
    bfd8:	ea000001 	b	bfe4 <rtems_blkdev_ioctl+0x64>                  <== NOT EXECUTED
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *arg_size = dd->size;                                     
    bfdc:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
    bfe0:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
    bfe4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
            break;                                                    
    bfe8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
        default:                                                      
            errno = EINVAL;                                           
    bfec:	eb0013d7 	bl	10f50 <__errno>                                
    bff0:	e3a03016 	mov	r3, #22                                       
    bff4:	e5803000 	str	r3, [r0]                                      
    bff8:	e3e00000 	mvn	r0, #0                                        
            rc = -1;                                                  
            break;                                                    
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
    bffc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

00001868 <rtems_bsp_cmdline_get_param>: size_t length ) { const char *p; if ( !name )
    1868:	e3500000 	cmp	r0, #0                                        
const char *rtems_bsp_cmdline_get_param(                              
  const char *name,                                                   
  char       *value,                                                  
  size_t      length                                                  
)                                                                     
{                                                                     
    186c:	e92d4070 	push	{r4, r5, r6, lr}                             
    1870:	e1a04001 	mov	r4, r1                                        
    1874:	e1a05002 	mov	r5, r2                                        
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
    1878:	0a00001c 	beq	18f0 <rtems_bsp_cmdline_get_param+0x88>       
    return NULL;                                                      
                                                                      
  if ( !value )                                                       
    187c:	e3510000 	cmp	r1, #0                                        
    1880:	0a00001b 	beq	18f4 <rtems_bsp_cmdline_get_param+0x8c>       
    return NULL;                                                      
                                                                      
  if ( !length )                                                      
    1884:	e3520000 	cmp	r2, #0                                        
    1888:	0a000018 	beq	18f0 <rtems_bsp_cmdline_get_param+0x88>       
    return NULL;                                                      
                                                                      
  value[0] = '\0';                                                    
    188c:	e3a06000 	mov	r6, #0                                        
    1890:	e5c16000 	strb	r6, [r1]                                     
                                                                      
  p = rtems_bsp_cmdline_get_param_raw( name );                        
    1894:	eb000018 	bl	18fc <rtems_bsp_cmdline_get_param_raw>         
                                                                      
  if ( !p )                                                           
    1898:	e3500000 	cmp	r0, #0                                        
    189c:	0a000013 	beq	18f0 <rtems_bsp_cmdline_get_param+0x88>       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    18a0:	e2455001 	sub	r5, r5, #1                                    
                                                                      
  value[0] = '\0';                                                    
                                                                      
  p = rtems_bsp_cmdline_get_param_raw( name );                        
                                                                      
  if ( !p )                                                           
    18a4:	e1a03006 	mov	r3, r6                                        
    if ( *p == '\"' ) {                                               
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
      break;                                                          
    value[i++] = *p++;                                                
    value[i] = '\0';                                                  
    18a8:	e1a01006 	mov	r1, r6                                        
    18ac:	ea000009 	b	18d8 <rtems_bsp_cmdline_get_param+0x70>         
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    if ( *p == '\"' ) {                                               
    18b0:	e3520022 	cmp	r2, #34	; 0x22                                
      quotes++;                                                       
    18b4:	02866001 	addeq	r6, r6, #1                                  
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    if ( *p == '\"' ) {                                               
    18b8:	0a000003 	beq	18cc <rtems_bsp_cmdline_get_param+0x64>       
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
    18bc:	e3160001 	tst	r6, #1                                        
    18c0:	1a000001 	bne	18cc <rtems_bsp_cmdline_get_param+0x64>       
    18c4:	e3520020 	cmp	r2, #32                                       
    18c8:	0a000009 	beq	18f4 <rtems_bsp_cmdline_get_param+0x8c>       
      break;                                                          
    value[i++] = *p++;                                                
    18cc:	e7c42003 	strb	r2, [r4, r3]                                 
    18d0:	e2833001 	add	r3, r3, #1                                    
    value[i] = '\0';                                                  
    18d4:	e7c41003 	strb	r1, [r4, r3]                                 
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    18d8:	e7d02003 	ldrb	r2, [r0, r3]                                 
    18dc:	e3520000 	cmp	r2, #0                                        
    18e0:	0a000003 	beq	18f4 <rtems_bsp_cmdline_get_param+0x8c>       
    18e4:	e1530005 	cmp	r3, r5                                        
    18e8:	3afffff0 	bcc	18b0 <rtems_bsp_cmdline_get_param+0x48>       
    18ec:	ea000000 	b	18f4 <rtems_bsp_cmdline_get_param+0x8c>         <== NOT EXECUTED
    18f0:	e3a04000 	mov	r4, #0                                        
    return NULL;                                                      
                                                                      
  copy_string( p, value, length );                                    
                                                                      
  return value;                                                       
}                                                                     
    18f4:	e1a00004 	mov	r0, r4                                        
    18f8:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

0000247c <rtems_cpu_usage_report_with_plugin>: void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) {
    247c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
    Timestamp_Control  uptime, total, ran;                            
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
    2480:	e251a000 	subs	sl, r1, #0                                   
                                                                      
void rtems_cpu_usage_report_with_plugin(                              
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
    2484:	e24dd040 	sub	sp, sp, #64	; 0x40                            
    2488:	e1a08000 	mov	r8, r0                                        
    Timestamp_Control  uptime, total, ran;                            
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
    248c:	0a000059 	beq	25f8 <rtems_cpu_usage_report_with_plugin+0x17c>
   *  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__                          
    _TOD_Get_uptime( &uptime );                                       
    2490:	e28d4030 	add	r4, sp, #48	; 0x30                            
    2494:	e1a00004 	mov	r0, r4                                        
    _Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
    2498:	e28d5028 	add	r5, sp, #40	; 0x28                            
   *  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__                          
    _TOD_Get_uptime( &uptime );                                       
    249c:	eb0014e0 	bl	7824 <_TOD_Get_uptime>                         
    _Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
    24a0:	e1a01004 	mov	r1, r4                                        
    24a4:	e1a02005 	mov	r2, r5                                        
    24a8:	e59f0150 	ldr	r0, [pc, #336]	; 2600 <rtems_cpu_usage_report_with_plugin+0x184>
    24ac:	eb001dc3 	bl	9bc0 <_Timespec_Subtract>                      
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
    24b0:	e1a00008 	mov	r0, r8                                        
    24b4:	e59f1148 	ldr	r1, [pc, #328]	; 2604 <rtems_cpu_usage_report_with_plugin+0x188>
    24b8:	e1a0e00f 	mov	lr, pc                                        
    24bc:	e12fff1a 	bx	sl                                             
    24c0:	e59f4140 	ldr	r4, [pc, #320]	; 2608 <rtems_cpu_usage_report_with_plugin+0x18c>
          /*                                                          
           * 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 ) {
    24c4:	e59fb140 	ldr	fp, [pc, #320]	; 260c <rtems_cpu_usage_report_with_plugin+0x190>
  );                                                                  
                                                                      
  for ( api_index = 1 ;                                               
        api_index <= OBJECTS_APIS_LAST ;                              
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
    24c8:	e5943004 	ldr	r3, [r4, #4]                                  
    24cc:	e3530000 	cmp	r3, #0                                        
    24d0:	0a00003b 	beq	25c4 <rtems_cpu_usage_report_with_plugin+0x148>
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    24d4:	e5936004 	ldr	r6, [r3, #4]                                  
    if ( information ) {                                              
    24d8:	e3560000 	cmp	r6, #0                                        
    24dc:	13a07001 	movne	r7, #1                                      
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
          if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
            Timestamp_Control used;                                   
            _Timestamp_Subtract(                                      
    24e0:	128d9018 	addne	r9, sp, #24                                 
    24e4:	11a05004 	movne	r5, r4                                      
        api_index <= OBJECTS_APIS_LAST ;                              
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
    24e8:	1a00002f 	bne	25ac <rtems_cpu_usage_report_with_plugin+0x130>
    24ec:	ea000034 	b	25c4 <rtems_cpu_usage_report_with_plugin+0x148> <== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
        the_thread = (Thread_Control *)information->local_table[ i ]; 
    24f0:	e596301c 	ldr	r3, [r6, #28]                                 
    24f4:	e7934107 	ldr	r4, [r3, r7, lsl #2]                          
                                                                      
        if ( !the_thread )                                            
    24f8:	e3540000 	cmp	r4, #0                                        
    24fc:	0a000029 	beq	25a8 <rtems_cpu_usage_report_with_plugin+0x12c>
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
    2500:	e5940008 	ldr	r0, [r4, #8]                                  
    2504:	eb001041 	bl	6610 <rtems_object_get_name>                   
                                                                      
        (*print)(                                                     
    2508:	e28d3008 	add	r3, sp, #8                                    
    250c:	e5942008 	ldr	r2, [r4, #8]                                  
    2510:	e1a00008 	mov	r0, r8                                        
    2514:	e59f10f4 	ldr	r1, [pc, #244]	; 2610 <rtems_cpu_usage_report_with_plugin+0x194>
    2518:	e1a0e00f 	mov	lr, pc                                        
    251c:	e12fff1a 	bx	sl                                             
        #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;                            
    2520:	e2843084 	add	r3, r4, #132	; 0x84                           
    2524:	e893000c 	ldm	r3, {r2, r3}                                  
    2528:	e58d2020 	str	r2, [sp, #32]                                 
    252c:	e58d3024 	str	r3, [sp, #36]	; 0x24                          
          if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
    2530:	e59b2000 	ldr	r2, [fp]                                      
    2534:	e5943008 	ldr	r3, [r4, #8]                                  
    2538:	e5922008 	ldr	r2, [r2, #8]                                  
    253c:	e1520003 	cmp	r2, r3                                        
    2540:	1a000006 	bne	2560 <rtems_cpu_usage_report_with_plugin+0xe4>
            Timestamp_Control used;                                   
            _Timestamp_Subtract(                                      
    2544:	e59f00c8 	ldr	r0, [pc, #200]	; 2614 <rtems_cpu_usage_report_with_plugin+0x198>
    2548:	e28d1030 	add	r1, sp, #48	; 0x30                            
    254c:	e1a02009 	mov	r2, r9                                        
    2550:	eb001d9a 	bl	9bc0 <_Timespec_Subtract>                      
              &_Thread_Time_of_last_context_switch, &uptime, &used    
            );                                                        
            _Timestamp_Add_to( &ran, &used );                         
    2554:	e28d0020 	add	r0, sp, #32                                   
    2558:	e1a01009 	mov	r1, r9                                        
    255c:	eb001d5c 	bl	9ad4 <_Timespec_Add_to>                        
          };                                                          
          _Timestamp_Divide( &ran, &total, &ival, &fval );            
    2560:	e28d203c 	add	r2, sp, #60	; 0x3c                            
    2564:	e28d3038 	add	r3, sp, #56	; 0x38                            
    2568:	e28d0020 	add	r0, sp, #32                                   
    256c:	e28d1028 	add	r1, sp, #40	; 0x28                            
    2570:	eb001d6c 	bl	9b28 <_Timespec_Divide>                        
                                                                      
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          (*print)( context,                                          
    2574:	e3a01ffa 	mov	r1, #1000	; 0x3e8                             
    2578:	e59d0024 	ldr	r0, [sp, #36]	; 0x24                          
    257c:	eb0065a7 	bl	1bc20 <__aeabi_uidiv>                          
    2580:	e59d203c 	ldr	r2, [sp, #60]	; 0x3c                          
    2584:	e58d2000 	str	r2, [sp]                                      
    2588:	e59d2038 	ldr	r2, [sp, #56]	; 0x38                          
    258c:	e1a03000 	mov	r3, r0                                        
    2590:	e58d2004 	str	r2, [sp, #4]                                  
    2594:	e1a00008 	mov	r0, r8                                        
    2598:	e59f1078 	ldr	r1, [pc, #120]	; 2618 <rtems_cpu_usage_report_with_plugin+0x19c>
    259c:	e59d2020 	ldr	r2, [sp, #32]                                 
    25a0:	e1a0e00f 	mov	lr, pc                                        
    25a4:	e12fff1a 	bx	sl                                             
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
    25a8:	e2877001 	add	r7, r7, #1                                    
    25ac:	e1d631b0 	ldrh	r3, [r6, #16]                                
    25b0:	e1570003 	cmp	r7, r3                                        
        the_thread = (Thread_Control *)information->local_table[ i ]; 
                                                                      
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
    25b4:	e3a0100d 	mov	r1, #13                                       
    25b8:	e28d2008 	add	r2, sp, #8                                    
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
    25bc:	9affffcb 	bls	24f0 <rtems_cpu_usage_report_with_plugin+0x74>
    25c0:	e1a04005 	mov	r4, r5                                        
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ;                                               
    25c4:	e59f3050 	ldr	r3, [pc, #80]	; 261c <rtems_cpu_usage_report_with_plugin+0x1a0>
        api_index++ ) {                                               
    if ( !_Objects_Information_table[ api_index ] )                   
      continue;                                                       
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
    25c8:	e2844004 	add	r4, r4, #4                                    
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ;                                               
    25cc:	e1540003 	cmp	r4, r3                                        
    25d0:	1affffbc 	bne	24c8 <rtems_cpu_usage_report_with_plugin+0x4c>
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)(                                                         
    25d4:	e3a01ffa 	mov	r1, #1000	; 0x3e8                             
    25d8:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          
    25dc:	eb00658f 	bl	1bc20 <__aeabi_uidiv>                          
    25e0:	e59f1038 	ldr	r1, [pc, #56]	; 2620 <rtems_cpu_usage_report_with_plugin+0x1a4>
    25e4:	e1a03000 	mov	r3, r0                                        
    25e8:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          
    25ec:	e1a00008 	mov	r0, r8                                        
    25f0:	e1a0e00f 	mov	lr, pc                                        
    25f4:	e12fff1a 	bx	sl                                             
       "-------------------------------------------------------------------------------\n",
       _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,    
       total_units                                                    
    );                                                                
  #endif                                                              
}                                                                     
    25f8:	e28dd040 	add	sp, sp, #64	; 0x40                            
    25fc:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
                                                                      

0000d310 <rtems_deviceio_errno>: { 0, 0, 0 }, }; int rtems_deviceio_errno(rtems_status_code code) {
    d310:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
    d314:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
    int rc;                                                           
                                                                      
    if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t  ) code)))
    d318:	e59f0018 	ldr	r0, [pc, #24]	; d338 <rtems_deviceio_errno+0x28><== NOT EXECUTED
    d31c:	eb000006 	bl	d33c <rtems_assoc_remote_by_local>             <== NOT EXECUTED
    d320:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
    d324:	0a000001 	beq	d330 <rtems_deviceio_errno+0x20>              <== NOT EXECUTED
    {                                                                 
        errno = rc;                                                   
    d328:	eb000025 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    d32c:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
        return -1;                                                    
    }                                                                 
    return -1;                                                        
}                                                                     
    d330:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    d334:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00001ef8 <rtems_disk_delete>: } } rtems_status_code rtems_disk_delete(dev_t dev) {
    1ef8:	e92d4ff7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    1efc:	e1a05000 	mov	r5, r0                                        
    1f00:	e1a06001 	mov	r6, r1                                        
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *dd = NULL;                                       
                                                                      
  sc = disk_lock();                                                   
    1f04:	ebffff91 	bl	1d50 <disk_lock>                               
  if (sc != RTEMS_SUCCESSFUL) {                                       
    1f08:	e2504000 	subs	r4, r0, #0                                   
    1f0c:	1a000057 	bne	2070 <rtems_disk_delete+0x178>                
    return sc;                                                        
  }                                                                   
                                                                      
  dd = get_disk_entry(dev, true);                                     
    1f10:	e1a00005 	mov	r0, r5                                        
    1f14:	e1a01006 	mov	r1, r6                                        
    1f18:	e3a02001 	mov	r2, #1                                        
    1f1c:	ebffff12 	bl	1b6c <get_disk_entry>                          
  if (dd == NULL) {                                                   
    1f20:	e2503000 	subs	r3, r0, #0                                   
    1f24:	1a000002 	bne	1f34 <rtems_disk_delete+0x3c>                 
    disk_unlock();                                                    
    1f28:	ebffff94 	bl	1d80 <disk_unlock>                             <== NOT EXECUTED
    1f2c:	e3a04004 	mov	r4, #4                                        <== NOT EXECUTED
                                                                      
    return RTEMS_INVALID_ID;                                          
    1f30:	ea00004e 	b	2070 <rtems_disk_delete+0x178>                  <== NOT EXECUTED
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
    1f34:	e3a0b001 	mov	fp, #1                                        
    1f38:	e5c3b030 	strb	fp, [r3, #48]	; 0x30                         
}                                                                     
                                                                      
static void                                                           
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)                 
{                                                                     
  rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;  
    1f3c:	e5935008 	ldr	r5, [r3, #8]                                  
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  if (physical_disk->deleted) {                                       
    1f40:	e5d52030 	ldrb	r2, [r5, #48]	; 0x30                         
    1f44:	e3520000 	cmp	r2, #0                                        
    1f48:	0a00003a 	beq	2038 <rtems_disk_delete+0x140>                
    dev_t dev = physical_disk->dev;                                   
    1f4c:	e895000c 	ldm	r5, {r2, r3}                                  
    1f50:	e98d000c 	stmib	sp, {r2, r3}                                
    1f54:	e1a07004 	mov	r7, r4                                        
    1f58:	e1a08004 	mov	r8, r4                                        
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
    1f5c:	e59fa114 	ldr	sl, [pc, #276]	; 2078 <rtems_disk_delete+0x180>
    1f60:	ea000024 	b	1ff8 <rtems_disk_delete+0x100>                  
      rtems_disk_device_table *dtab = disktab + major;                
    1f64:	e59a9004 	ldr	r9, [sl, #4]                                  
    1f68:	e3a06000 	mov	r6, #0                                        
    1f6c:	e0899187 	add	r9, r9, r7, lsl #3                            
    1f70:	ea00001c 	b	1fe8 <rtems_disk_delete+0xf0>                   
                                                                      
      for (minor = 0; minor < dtab->size; ++minor) {                  
        rtems_disk_device *dd = dtab->minor [minor];                  
    1f74:	e5993000 	ldr	r3, [r9]                                      
    1f78:	e7930106 	ldr	r0, [r3, r6, lsl #2]                          
    1f7c:	e1a0c106 	lsl	ip, r6, #2                                    
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
    1f80:	e3500000 	cmp	r0, #0                                        
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
      rtems_disk_device_table *dtab = disktab + major;                
                                                                      
      for (minor = 0; minor < dtab->size; ++minor) {                  
        rtems_disk_device *dd = dtab->minor [minor];                  
    1f84:	e58dc000 	str	ip, [sp]                                      
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
    1f88:	0a000015 	beq	1fe4 <rtems_disk_delete+0xec>                 
    1f8c:	e5901008 	ldr	r1, [r0, #8]                                  
    1f90:	e59d2004 	ldr	r2, [sp, #4]                                  
    1f94:	e591c000 	ldr	ip, [r1]                                      
    1f98:	e050e005 	subs	lr, r0, r5                                   
    1f9c:	13a0e001 	movne	lr, #1                                      
    1fa0:	e15c0002 	cmp	ip, r2                                        
    1fa4:	e3a02000 	mov	r2, #0                                        
    1fa8:	1a000003 	bne	1fbc <rtems_disk_delete+0xc4>                 
    1fac:	e5911004 	ldr	r1, [r1, #4]                                  
    1fb0:	e59dc008 	ldr	ip, [sp, #8]                                  
    1fb4:	e151000c 	cmp	r1, ip                                        
    1fb8:	03a02001 	moveq	r2, #1                                      
    1fbc:	e11e0002 	tst	lr, r2                                        
    1fc0:	0a000007 	beq	1fe4 <rtems_disk_delete+0xec>                 
          if (dd->uses == 0) {                                        
    1fc4:	e5902014 	ldr	r2, [r0, #20]                                 
    1fc8:	e3520000 	cmp	r2, #0                                        
            ++deleted_count;                                          
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
          } else {                                                    
            dd->deleted = true;                                       
    1fcc:	11a0200b 	movne	r2, fp                                      
    1fd0:	15c02030 	strbne	r2, [r0, #48]	; 0x30                       
        rtems_disk_device *dd = dtab->minor [minor];                  
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
          if (dd->uses == 0) {                                        
            ++deleted_count;                                          
            dtab->minor [minor] = NULL;                               
    1fd4:	059d1000 	ldreq	r1, [sp]                                    
    1fd8:	07832001 	streq	r2, [r3, r1]                                
      for (minor = 0; minor < dtab->size; ++minor) {                  
        rtems_disk_device *dd = dtab->minor [minor];                  
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
          if (dd->uses == 0) {                                        
            ++deleted_count;                                          
    1fdc:	02888001 	addeq	r8, r8, #1                                  
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
    1fe0:	0bfffefe 	bleq	1be0 <free_disk_device>                      
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
      rtems_disk_device_table *dtab = disktab + major;                
                                                                      
      for (minor = 0; minor < dtab->size; ++minor) {                  
    1fe4:	e2866001 	add	r6, r6, #1                                    
    1fe8:	e5993004 	ldr	r3, [r9, #4]                                  
    1fec:	e1560003 	cmp	r6, r3                                        
    1ff0:	3affffdf 	bcc	1f74 <rtems_disk_delete+0x7c>                 
                                                                      
  if (physical_disk->deleted) {                                       
    dev_t dev = physical_disk->dev;                                   
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
    1ff4:	e2877001 	add	r7, r7, #1                                    
    1ff8:	e59a3000 	ldr	r3, [sl]                                      
    1ffc:	e1570003 	cmp	r7, r3                                        
    2000:	3affffd7 	bcc	1f64 <rtems_disk_delete+0x6c>                 
          }                                                           
        }                                                             
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    2004:	e5953014 	ldr	r3, [r5, #20]                                 
    2008:	e0688003 	rsb	r8, r8, r3                                    
    if (physical_disk->uses == 0) {                                   
    200c:	e3580000 	cmp	r8, #0                                        
          }                                                           
        }                                                             
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    2010:	e5858014 	str	r8, [r5, #20]                                 
    if (physical_disk->uses == 0) {                                   
    2014:	1a000014 	bne	206c <rtems_disk_delete+0x174>                
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
      disktab [major].minor [minor] = NULL;                           
    2018:	e59f3058 	ldr	r3, [pc, #88]	; 2078 <rtems_disk_delete+0x180>
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
    201c:	e5952000 	ldr	r2, [r5]                                      
      disktab [major].minor [minor] = NULL;                           
    2020:	e5933004 	ldr	r3, [r3, #4]                                  
    2024:	e7933182 	ldr	r3, [r3, r2, lsl #3]                          
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
    2028:	e5952004 	ldr	r2, [r5, #4]                                  
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    202c:	e1a00005 	mov	r0, r5                                        
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
      disktab [major].minor [minor] = NULL;                           
    2030:	e7838102 	str	r8, [r3, r2, lsl #2]                          
    2034:	ea00000b 	b	2068 <rtems_disk_delete+0x170>                  
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
    2038:	e5932014 	ldr	r2, [r3, #20]                                 
    203c:	e3520000 	cmp	r2, #0                                        
    2040:	1a000009 	bne	206c <rtems_disk_delete+0x174>                
      --physical_disk->uses;                                          
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
    2044:	e59f202c 	ldr	r2, [pc, #44]	; 2078 <rtems_disk_delete+0x180>
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
    2048:	e593c000 	ldr	ip, [r3]                                      
      disktab [major].minor [minor] = NULL;                           
    204c:	e5922004 	ldr	r2, [r2, #4]                                  
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
    2050:	e5951014 	ldr	r1, [r5, #20]                                 
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
    2054:	e792218c 	ldr	r2, [r2, ip, lsl #3]                          
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
    2058:	e5933004 	ldr	r3, [r3, #4]                                  
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
    205c:	e2411001 	sub	r1, r1, #1                                    
    2060:	e5851014 	str	r1, [r5, #20]                                 
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
    2064:	e7824103 	str	r4, [r2, r3, lsl #2]                          
      free_disk_device(disk_to_remove);                               
    2068:	ebfffedc 	bl	1be0 <free_disk_device>                        
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
    206c:	ebffff43 	bl	1d80 <disk_unlock>                             
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    2070:	e1a00004 	mov	r0, r4                                        
    2074:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
                                                                      

00001cb0 <rtems_disk_io_initialize>: } } rtems_status_code rtems_disk_io_initialize(void) {
    1cb0:	e92d4031 	push	{r0, r4, r5, lr}                             
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_device_major_number size = DISKTAB_INITIAL_SIZE;              
                                                                      
  if (disktab_size > 0) {                                             
    1cb4:	e59f408c 	ldr	r4, [pc, #140]	; 1d48 <rtems_disk_io_initialize+0x98>
    1cb8:	e5945000 	ldr	r5, [r4]                                      
    1cbc:	e3550000 	cmp	r5, #0                                        
    1cc0:	13a00000 	movne	r0, #0                                      
    1cc4:	1a00001e 	bne	1d44 <rtems_disk_io_initialize+0x94>          
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
    1cc8:	e3a00008 	mov	r0, #8                                        
    1ccc:	e1a01000 	mov	r1, r0                                        
    1cd0:	eb0003b1 	bl	2b9c <calloc>                                  
  if (disktab == NULL) {                                              
    1cd4:	e3500000 	cmp	r0, #0                                        
                                                                      
  if (disktab_size > 0) {                                             
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
    1cd8:	e5840004 	str	r0, [r4, #4]                                  
  if (disktab == NULL) {                                              
    1cdc:	0280001a 	addeq	r0, r0, #26                                 
    1ce0:	0a000017 	beq	1d44 <rtems_disk_io_initialize+0x94>          
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  diskdevs_protected = false;                                         
  sc = rtems_semaphore_create(                                        
    1ce4:	e284c008 	add	ip, r4, #8                                    
    1ce8:	e1a03005 	mov	r3, r5                                        
    1cec:	e59f0058 	ldr	r0, [pc, #88]	; 1d4c <rtems_disk_io_initialize+0x9c>
    1cf0:	e3a01001 	mov	r1, #1                                        
    1cf4:	e3a02010 	mov	r2, #16                                       
    1cf8:	e58dc000 	str	ip, [sp]                                      
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
  if (disktab == NULL) {                                              
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  diskdevs_protected = false;                                         
    1cfc:	e5c4500c 	strb	r5, [r4, #12]                                
  sc = rtems_semaphore_create(                                        
    1d00:	eb00110d 	bl	613c <rtems_semaphore_create>                  
    RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY   
      | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,                      
    0,                                                                
    &diskdevs_mutex                                                   
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
    1d04:	e3500000 	cmp	r0, #0                                        
    1d08:	0a000003 	beq	1d1c <rtems_disk_io_initialize+0x6c>          
    free(disktab);                                                    
    1d0c:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
    1d10:	eb000429 	bl	2dbc <free>                                    <== NOT EXECUTED
    1d14:	e3a0001a 	mov	r0, #26                                       <== NOT EXECUTED
                                                                      
    return RTEMS_NO_MEMORY;                                           
    1d18:	ea000009 	b	1d44 <rtems_disk_io_initialize+0x94>            <== NOT EXECUTED
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
    1d1c:	eb002163 	bl	a2b0 <rtems_bdbuf_init>                        
  if (sc != RTEMS_SUCCESSFUL) {                                       
    1d20:	e3500000 	cmp	r0, #0                                        
    free(disktab);                                                    
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  disktab_size = size;                                                
    1d24:	03a03008 	moveq	r3, #8                                      
    1d28:	05843000 	streq	r3, [r4]                                    
                                                                      
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
    1d2c:	0a000004 	beq	1d44 <rtems_disk_io_initialize+0x94>          
    rtems_semaphore_delete(diskdevs_mutex);                           
    1d30:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    1d34:	eb00116b 	bl	62e8 <rtems_semaphore_delete>                  <== NOT EXECUTED
    free(disktab);                                                    
    1d38:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
    1d3c:	eb00041e 	bl	2dbc <free>                                    <== NOT EXECUTED
    1d40:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
  }                                                                   
                                                                      
  disktab_size = size;                                                
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    1d44:	e8bd8038 	pop	{r3, r4, r5, pc}                              
                                                                      

00001db0 <rtems_disk_next>: rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_disk_device_table *dtab = NULL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; if (dev != (dev_t) -1) {
    1db0:	e3700001 	cmn	r0, #1                                        
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_disk_device *                                                   
rtems_disk_next(dev_t dev)                                            
{                                                                     
    1db4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device_table *dtab = NULL;                               
  rtems_device_major_number major = 0;                                
  rtems_device_minor_number minor = 0;                                
                                                                      
  if (dev != (dev_t) -1) {                                            
    1db8:	1a000003 	bne	1dcc <rtems_disk_next+0x1c>                   
    1dbc:	e3710001 	cmn	r1, #1                                        
    1dc0:	03a04000 	moveq	r4, #0                                      
    1dc4:	01a05004 	moveq	r5, r4                                      
    1dc8:	0a000005 	beq	1de4 <rtems_disk_next+0x34>                   
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
    /* If minor wraps around */                                       
    if ((minor + 1) < minor) {                                        
    1dcc:	e2914001 	adds	r4, r1, #1                                   
    1dd0:	31a05000 	movcc	r5, r0                                      
    1dd4:	3a000002 	bcc	1de4 <rtems_disk_next+0x34>                   
      /* If major wraps around */                                     
      if ((major + 1) < major) {                                      
    1dd8:	e2905001 	adds	r5, r0, #1                                   <== NOT EXECUTED
    1ddc:	2a000027 	bcs	1e80 <rtems_disk_next+0xd0>                   <== NOT EXECUTED
    1de0:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    } else {                                                          
      ++minor;                                                        
    }                                                                 
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
    1de4:	ebffffd9 	bl	1d50 <disk_lock>                               
  if (sc != RTEMS_SUCCESSFUL) {                                       
    1de8:	e2506000 	subs	r6, r0, #0                                   
    1dec:	1a000023 	bne	1e80 <rtems_disk_next+0xd0>                   
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
    1df0:	e59f3090 	ldr	r3, [pc, #144]	; 1e88 <rtems_disk_next+0xd8>  
    1df4:	e5931000 	ldr	r1, [r3]                                      
    1df8:	e1550001 	cmp	r5, r1                                        
    disk_unlock();                                                    
                                                                      
    return NULL;                                                      
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
    1dfc:	35932004 	ldrcc	r2, [r3, #4]                                
    1e00:	30826185 	addcc	r6, r2, r5, lsl #3                          
  sc = disk_lock();                                                   
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
    1e04:	3a000002 	bcc	1e14 <rtems_disk_next+0x64>                   
    disk_unlock();                                                    
    1e08:	ebffffdc 	bl	1d80 <disk_unlock>                             <== NOT EXECUTED
    1e0c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
    return NULL;                                                      
    1e10:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
    1e14:	e5963000 	ldr	r3, [r6]                                      
    1e18:	e3530000 	cmp	r3, #0                                        
    1e1c:	0a000002 	beq	1e2c <rtems_disk_next+0x7c>                   
    1e20:	e5960004 	ldr	r0, [r6, #4]                                  
    1e24:	e1540000 	cmp	r4, r0                                        
    1e28:	3a000008 	bcc	1e50 <rtems_disk_next+0xa0>                   
       minor = 0;                                                     
       ++major;                                                       
    1e2c:	e2855001 	add	r5, r5, #1                                    
       if (major >= disktab_size) {                                   
    1e30:	e1550001 	cmp	r5, r1                                        
    1e34:	3a000002 	bcc	1e44 <rtems_disk_next+0x94>                   
         disk_unlock();                                               
    1e38:	ebffffd0 	bl	1d80 <disk_unlock>                             
    1e3c:	e3a00000 	mov	r0, #0                                        
                                                                      
         return NULL;                                                 
    1e40:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
       }                                                              
       dtab = disktab + major;                                        
    1e44:	e0826185 	add	r6, r2, r5, lsl #3                            
    1e48:	e3a04000 	mov	r4, #0                                        
    return NULL;                                                      
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
    1e4c:	eafffff0 	b	1e14 <rtems_disk_next+0x64>                     
         disk_unlock();                                               
                                                                      
         return NULL;                                                 
       }                                                              
       dtab = disktab + major;                                        
    } else if (dtab->minor [minor] == NULL) {                         
    1e50:	e7933104 	ldr	r3, [r3, r4, lsl #2]                          
    1e54:	e3530000 	cmp	r3, #0                                        
    1e58:	e1a07104 	lsl	r7, r4, #2                                    
      ++minor;                                                        
    1e5c:	02844001 	addeq	r4, r4, #1                                  
    1e60:	0affffeb 	beq	1e14 <rtems_disk_next+0x64>                   
    } else {                                                          
      ++dtab->minor [minor]->uses;                                    
    1e64:	e5932014 	ldr	r2, [r3, #20]                                 
    1e68:	e2822001 	add	r2, r2, #1                                    
    1e6c:	e5832014 	str	r2, [r3, #20]                                 
      disk_unlock();                                                  
    1e70:	ebffffc2 	bl	1d80 <disk_unlock>                             
                                                                      
      return dtab->minor [minor];                                     
    1e74:	e5963000 	ldr	r3, [r6]                                      
    1e78:	e7930007 	ldr	r0, [r3, r7]                                  
    1e7c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
    1e80:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
}                                                                     
    1e84:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00001e8c <rtems_disk_obtain>: return RTEMS_SUCCESSFUL; } rtems_disk_device * rtems_disk_obtain(dev_t dev) {
    1e8c:	e92d4070 	push	{r4, r5, r6, lr}                             
    1e90:	e1a05000 	mov	r5, r0                                        
    1e94:	e1a06001 	mov	r6, r1                                        
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    1e98:	e10f4000 	mrs	r4, CPSR                                      
    1e9c:	e3843080 	orr	r3, r4, #128	; 0x80                           
    1ea0:	e129f003 	msr	CPSR_fc, r3                                   
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *dd = NULL;                                       
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable(level);                                     
  if (!diskdevs_protected) {                                          
    1ea4:	e59f3048 	ldr	r3, [pc, #72]	; 1ef4 <rtems_disk_obtain+0x68> 
    1ea8:	e5d3200c 	ldrb	r2, [r3, #12]                                
    1eac:	e21220ff 	ands	r2, r2, #255	; 0xff                          
    1eb0:	1a000003 	bne	1ec4 <rtems_disk_obtain+0x38>                 
    /* Frequent and quickest case */                                  
    dd = get_disk_entry(dev, false);                                  
    1eb4:	ebffff2c 	bl	1b6c <get_disk_entry>                          
    1eb8:	e1a05000 	mov	r5, r0                                        
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    1ebc:	e129f004 	msr	CPSR_fc, r4                                   
    1ec0:	ea000009 	b	1eec <rtems_disk_obtain+0x60>                   
    1ec4:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
  } else {                                                            
    rtems_interrupt_enable(level);                                    
                                                                      
    sc = disk_lock();                                                 
    1ec8:	ebffffa0 	bl	1d50 <disk_lock>                               <== NOT EXECUTED
    if (sc == RTEMS_SUCCESSFUL) {                                     
    1ecc:	e2502000 	subs	r2, r0, #0                                   <== NOT EXECUTED
    1ed0:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
    1ed4:	1a000004 	bne	1eec <rtems_disk_obtain+0x60>                 <== NOT EXECUTED
      dd = get_disk_entry(dev, false);                                
    1ed8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    1edc:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    1ee0:	ebffff21 	bl	1b6c <get_disk_entry>                          <== NOT EXECUTED
    1ee4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
      disk_unlock();                                                  
    1ee8:	ebffffa4 	bl	1d80 <disk_unlock>                             <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return dd;                                                          
}                                                                     
    1eec:	e1a00005 	mov	r0, r5                                        
    1ef0:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

0001d1fc <rtems_dosfs_initialize>: int rtems_dosfs_initialize(rtems_filesystem_mount_table_entry_t *mt_entry, const void *data) { int rc; rc = msdos_initialize_support(mt_entry,
   1d1fc:	e59f1008 	ldr	r1, [pc, #8]	; 1d20c <rtems_dosfs_initialize+0x10><== NOT EXECUTED
   1d200:	e59f2008 	ldr	r2, [pc, #8]	; 1d210 <rtems_dosfs_initialize+0x14><== NOT EXECUTED
   1d204:	e59f3008 	ldr	r3, [pc, #8]	; 1d214 <rtems_dosfs_initialize+0x18><== NOT EXECUTED
   1d208:	ea000002 	b	1d218 <msdos_initialize_support>                <== NOT EXECUTED
                                                                      

00006680 <rtems_error>: int rtems_error( rtems_error_code_t error_flag, const char *printf_format, ... ) {
    6680:	e92d000e 	push	{r1, r2, r3}                                 <== NOT EXECUTED
    6684:	e92d4001 	push	{r0, lr}                                     <== NOT EXECUTED
    va_list arglist;                                                  
    int chars_written;                                                
                                                                      
    va_start(arglist, printf_format);                                 
    6688:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
    chars_written = rtems_verror(error_flag, printf_format, arglist); 
    668c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    6690:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
  )                                                                   
{                                                                     
    va_list arglist;                                                  
    int chars_written;                                                
                                                                      
    va_start(arglist, printf_format);                                 
    6694:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    chars_written = rtems_verror(error_flag, printf_format, arglist); 
    6698:	ebffff84 	bl	64b0 <rtems_verror>                            <== NOT EXECUTED
    va_end(arglist);                                                  
                                                                      
    return chars_written;                                             
}                                                                     
    669c:	e8bd4008 	pop	{r3, lr}                                      <== NOT EXECUTED
    66a0:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
    66a4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00001e58 <rtems_filesystem_evaluate_path>: size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) {
    1e58:	e92d40f3 	push	{r0, r1, r4, r5, r6, r7, lr}                 
  int                           i = 0;                                
    1e5c:	e3a0c000 	mov	ip, #0                                        
                                                                      
  /*                                                                  
   * Verify Input parameters.                                         
   */                                                                 
                                                                      
  if ( !pathname )                                                    
    1e60:	e2505000 	subs	r5, r0, #0                                   
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc,                         
  int                                follow_link                      
)                                                                     
{                                                                     
  int                           i = 0;                                
    1e64:	e58dc004 	str	ip, [sp, #4]                                  
  size_t                             pathnamelen,                     
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc,                         
  int                                follow_link                      
)                                                                     
{                                                                     
    1e68:	e1a06001 	mov	r6, r1                                        
    1e6c:	e1a04002 	mov	r4, r2                                        
    1e70:	e1a07003 	mov	r7, r3                                        
                                                                      
  /*                                                                  
   * Verify Input parameters.                                         
   */                                                                 
                                                                      
  if ( !pathname )                                                    
    1e74:	1a000002 	bne	1e84 <rtems_filesystem_evaluate_path+0x2c>    
    rtems_set_errno_and_return_minus_one( EFAULT );                   
    1e78:	eb002d51 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1e7c:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
    1e80:	ea000003 	b	1e94 <rtems_filesystem_evaluate_path+0x3c>      <== NOT EXECUTED
                                                                      
  if ( !pathloc )                                                     
    1e84:	e3530000 	cmp	r3, #0                                        
    1e88:	1a000004 	bne	1ea0 <rtems_filesystem_evaluate_path+0x48>    
    rtems_set_errno_and_return_minus_one( EIO );       /* should never happen */
    1e8c:	eb002d4c 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1e90:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
    1e94:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1e98:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    1e9c:	ea00000a 	b	1ecc <rtems_filesystem_evaluate_path+0x74>      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Evaluate the path using the optable evalpath.                    
   */                                                                 
                                                                      
  rtems_filesystem_get_start_loc( pathname, &i, pathloc );            
    1ea0:	e1a02003 	mov	r2, r3                                        
    1ea4:	e28d1004 	add	r1, sp, #4                                    
    1ea8:	eb0003a6 	bl	2d48 <rtems_filesystem_get_start_loc>          
                                                                      
  /*                                                                  
   * We evaluation the path relative to the start location we get got.
   */                                                                 
  return rtems_filesystem_evaluate_relative_path( &pathname[i],       
    1eac:	e59d0004 	ldr	r0, [sp, #4]                                  
    1eb0:	e59dc01c 	ldr	ip, [sp, #28]                                 
    1eb4:	e0601006 	rsb	r1, r0, r6                                    
    1eb8:	e1a02004 	mov	r2, r4                                        
    1ebc:	e0850000 	add	r0, r5, r0                                    
    1ec0:	e1a03007 	mov	r3, r7                                        
    1ec4:	e58dc000 	str	ip, [sp]                                      
    1ec8:	ebffffaa 	bl	1d78 <rtems_filesystem_evaluate_relative_path> 
                                                  pathnamelen - i,    
                                                  flags,              
                                                  pathloc,            
                                                  follow_link );      
}                                                                     
    1ecc:	e8bd80fc 	pop	{r2, r3, r4, r5, r6, r7, pc}                  
                                                                      

00001d78 <rtems_filesystem_evaluate_relative_path>: /* * Verify Input parameters. */ if ( !pathname )
    1d78:	e3500000 	cmp	r0, #0                                        
  size_t                             pathnamelen,                     
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc,                         
  int                                follow_link                      
)                                                                     
{                                                                     
    1d7c:	e92d4030 	push	{r4, r5, lr}                                 
    1d80:	e1a05002 	mov	r5, r2                                        
    1d84:	e1a04003 	mov	r4, r3                                        
                                                                      
  /*                                                                  
   * Verify Input parameters.                                         
   */                                                                 
                                                                      
  if ( !pathname )                                                    
    1d88:	1a000002 	bne	1d98 <rtems_filesystem_evaluate_relative_path+0x20>
    rtems_set_errno_and_return_minus_one( EFAULT );                   
    1d8c:	eb002d8c 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1d90:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
    1d94:	ea000027 	b	1e38 <rtems_filesystem_evaluate_relative_path+0xc0><== NOT EXECUTED
                                                                      
  if ( !pathloc )                                                     
    1d98:	e3530000 	cmp	r3, #0                                        
    1d9c:	1a000002 	bne	1dac <rtems_filesystem_evaluate_relative_path+0x34>
    rtems_set_errno_and_return_minus_one( EIO );       /* should never happen */
    1da0:	eb002d87 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1da4:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
    1da8:	ea000022 	b	1e38 <rtems_filesystem_evaluate_relative_path+0xc0><== NOT EXECUTED
                                                                      
  if ( !pathloc->ops->evalpath_h )                                    
    1dac:	e593c00c 	ldr	ip, [r3, #12]                                 
    1db0:	e59cc000 	ldr	ip, [ip]                                      
    1db4:	e35c0000 	cmp	ip, #0                                        
    1db8:	0a00001c 	beq	1e30 <rtems_filesystem_evaluate_relative_path+0xb8>
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
    1dbc:	e1a0e00f 	mov	lr, pc                                        
    1dc0:	e12fff1c 	bx	ip                                             
  /*                                                                  
   * Get the Node type and determine if you need to follow the link or
   * not.                                                             
   */                                                                 
                                                                      
  if ( (result == 0) && follow_link ) {                               
    1dc4:	e59d200c 	ldr	r2, [sp, #12]                                 
    1dc8:	e2703001 	rsbs	r3, r0, #1                                   
    1dcc:	33a03000 	movcc	r3, #0                                      
    1dd0:	e3520000 	cmp	r2, #0                                        
    1dd4:	03a03000 	moveq	r3, #0                                      
    1dd8:	e3530000 	cmp	r3, #0                                        
    1ddc:	08bd8030 	popeq	{r4, r5, pc}                                
                                                                      
    if ( !pathloc->ops->node_type_h ){                                
    1de0:	e594200c 	ldr	r2, [r4, #12]                                 
    1de4:	e5923010 	ldr	r3, [r2, #16]                                 
    1de8:	e3530000 	cmp	r3, #0                                        
    1dec:	0a00000a 	beq	1e1c <rtems_filesystem_evaluate_relative_path+0xa4>
      rtems_filesystem_freenode( pathloc );                           
      rtems_set_errno_and_return_minus_one( ENOTSUP );                
    }                                                                 
                                                                      
    type = (*pathloc->ops->node_type_h)( pathloc );                   
    1df0:	e1a00004 	mov	r0, r4                                        
    1df4:	e1a0e00f 	mov	lr, pc                                        
    1df8:	e12fff13 	bx	r3                                             
                                                                      
    if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||                    
    1dfc:	e2400003 	sub	r0, r0, #3                                    
    1e00:	e3500001 	cmp	r0, #1                                        
    1e04:	83a00000 	movhi	r0, #0                                      
    1e08:	88bd8030 	pophi	{r4, r5, pc}                                
         ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {                    
                                                                      
        if ( !pathloc->ops->eval_link_h ){                            
    1e0c:	e594200c 	ldr	r2, [r4, #12]                                 
    1e10:	e5923034 	ldr	r3, [r2, #52]	; 0x34                          
    1e14:	e3530000 	cmp	r3, #0                                        
    1e18:	1a000009 	bne	1e44 <rtems_filesystem_evaluate_relative_path+0xcc>
          rtems_filesystem_freenode( pathloc );                       
    1e1c:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
    1e20:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    1e24:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    1e28:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    1e2c:	112fff13 	bxne	r3                                           <== NOT EXECUTED
          rtems_set_errno_and_return_minus_one( ENOTSUP );            
    1e30:	eb002d63 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1e34:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    1e38:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1e3c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    1e40:	e8bd8030 	pop	{r4, r5, pc}                                  <== 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 );     
    1e44:	e1a00004 	mov	r0, r4                                        
    1e48:	e1a01005 	mov	r1, r5                                        
    1e4c:	e1a0e00f 	mov	lr, pc                                        
    1e50:	e12fff13 	bx	r3                                             
    }                                                                 
  }                                                                   
                                                                      
  return result;                                                      
}                                                                     
    1e54:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

00001b9c <rtems_filesystem_initialize>: * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) {
    1b9c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
    1ba0:	e59f20e4 	ldr	r2, [pc, #228]	; 1c8c <rtems_filesystem_initialize+0xf0>
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
    1ba4:	e59f60e4 	ldr	r6, [pc, #228]	; 1c90 <rtems_filesystem_initialize+0xf4>
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
    1ba8:	e5922000 	ldr	r2, [r2]                                      
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
    1bac:	e5963000 	ldr	r3, [r6]                                      
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
    1bb0:	e3520000 	cmp	r2, #0                                        
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
    1bb4:	e3a02012 	mov	r2, #18                                       
 *  configuration is a single instantiation of the IMFS or miniIMFS with
 *  a single "/dev" directory in it.                                  
 */                                                                   
                                                                      
void rtems_filesystem_initialize( void )                              
{                                                                     
    1bb8:	e24dd018 	sub	sp, sp, #24                                   
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
    1bbc:	e583202c 	str	r2, [r3, #44]	; 0x2c                          
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
    rtems_fatal_error_occurred( 0xABCD0001 );                         
    1bc0:	059f00cc 	ldreq	r0, [pc, #204]	; 1c94 <rtems_filesystem_initialize+0xf8>
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
    1bc4:	0a00000b 	beq	1bf8 <rtems_filesystem_initialize+0x5c>       
    rtems_fatal_error_occurred( 0xABCD0001 );                         
                                                                      
  mt = &rtems_filesystem_mount_table[0];                              
    1bc8:	e59f30c8 	ldr	r3, [pc, #200]	; 1c98 <rtems_filesystem_initialize+0xfc>
                                                                      
  status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
    1bcc:	e3a05000 	mov	r5, #0                                        
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_table_size == 0 )                       
    rtems_fatal_error_occurred( 0xABCD0001 );                         
                                                                      
  mt = &rtems_filesystem_mount_table[0];                              
    1bd0:	e5932000 	ldr	r2, [r3]                                      
                                                                      
  status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
    1bd4:	e58d5000 	str	r5, [sp]                                      
    1bd8:	e5923004 	ldr	r3, [r2, #4]                                  
    1bdc:	e2820008 	add	r0, r2, #8                                    
    1be0:	e8900003 	ldm	r0, {r0, r1}                                  
    1be4:	e5922000 	ldr	r2, [r2]                                      
    1be8:	eb000231 	bl	24b4 <mount>                                   
                                                                      
  if ( status == -1 )                                                 
    1bec:	e3700001 	cmn	r0, #1                                        
    1bf0:	1a000001 	bne	1bfc <rtems_filesystem_initialize+0x60>       
    rtems_fatal_error_occurred( 0xABCD0002 );                         
    1bf4:	e59f00a0 	ldr	r0, [pc, #160]	; 1c9c <rtems_filesystem_initialize+0x100><== NOT EXECUTED
    1bf8:	eb000eea 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      
  rtems_filesystem_link_counts = 0;                                   
    1bfc:	e5963000 	ldr	r3, [r6]                                      
   *       gonna hit performance.                                     
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
    1c00:	e28d4004 	add	r4, sp, #4                                    
  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;                                   
    1c04:	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);                 
    1c08:	e3a01001 	mov	r1, #1                                        
    1c0c:	e1a03004 	mov	r3, r4                                        
    1c10:	e1a02005 	mov	r2, r5                                        
    1c14:	e59f0084 	ldr	r0, [pc, #132]	; 1ca0 <rtems_filesystem_initialize+0x104>
  rtems_filesystem_root        = loc;                                 
    1c18:	e1a07004 	mov	r7, r4                                        
   *       gonna hit performance.                                     
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
    1c1c:	e58d5000 	str	r5, [sp]                                      
    1c20:	eb00008c 	bl	1e58 <rtems_filesystem_evaluate_path>          
  rtems_filesystem_root        = loc;                                 
    1c24:	e596c000 	ldr	ip, [r6]                                      
    1c28:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         
    1c2c:	e28cc018 	add	ip, ip, #24                                   
    1c30:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    1c34:	e5973000 	ldr	r3, [r7]                                      
  /* One more clone for the current node */                           
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
    1c38:	e1a02005 	mov	r2, r5                                        
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
  rtems_filesystem_root        = loc;                                 
    1c3c:	e58c3000 	str	r3, [ip]                                      
  /* One more clone for the current node */                           
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
    1c40:	e3a01001 	mov	r1, #1                                        
    1c44:	e1a03004 	mov	r3, r4                                        
    1c48:	e59f0050 	ldr	r0, [pc, #80]	; 1ca0 <rtems_filesystem_initialize+0x104>
    1c4c:	e58d5000 	str	r5, [sp]                                      
    1c50:	eb000080 	bl	1e58 <rtems_filesystem_evaluate_path>          
  rtems_filesystem_current     = loc;                                 
    1c54:	e596c000 	ldr	ip, [r6]                                      
    1c58:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         
    1c5c:	e28cc004 	add	ip, ip, #4                                    
    1c60:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    1c64:	e5973000 	ldr	r3, [r7]                                      
   *                                                                  
   *  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);                                      
    1c68:	e59f0034 	ldr	r0, [pc, #52]	; 1ca4 <rtems_filesystem_initialize+0x108>
  /* 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;                                 
    1c6c:	e58c3000 	str	r3, [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);                                      
    1c70:	e59f1030 	ldr	r1, [pc, #48]	; 1ca8 <rtems_filesystem_initialize+0x10c>
    1c74:	eb00019f 	bl	22f8 <mkdir>                                   
  if ( status != 0 )                                                  
    1c78:	e3500000 	cmp	r0, #0                                        
    rtems_fatal_error_occurred( 0xABCD0003 );                         
    1c7c:	159f0028 	ldrne	r0, [pc, #40]	; 1cac <rtems_filesystem_initialize+0x110>
   *  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);                                      
  if ( status != 0 )                                                  
    1c80:	1affffdc 	bne	1bf8 <rtems_filesystem_initialize+0x5c>       
   *  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.        
   */                                                                 
}                                                                     
    1c84:	e28dd018 	add	sp, sp, #24                                   
    1c88:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      

0000a628 <rtems_filesystem_register>: int rtems_filesystem_register( const char *type, rtems_filesystem_fsmount_me_t mount_h ) {
    a628:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
    a62c:	e1a08001 	mov	r8, r1                                        
    a630:	e1a06000 	mov	r6, r0                                        
  size_t fsn_size = sizeof( filesystem_node ) + strlen(type) + 1;     
    a634:	eb000f67 	bl	e3d8 <strlen>                                  
  filesystem_node *fsn = malloc( fsn_size );                          
    a638:	e2800011 	add	r0, r0, #17                                   
    a63c:	ebffdeef 	bl	2200 <malloc>                                  
  char *type_storage = (char *) fsn + sizeof( filesystem_node );      
                                                                      
  if ( fsn == NULL )                                                  
    a640:	e2504000 	subs	r4, r0, #0                                   
    a644:	1a000004 	bne	a65c <rtems_filesystem_register+0x34>         
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
    a648:	eb000b5d 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a64c:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
    a650:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    a654:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    a658:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  rtems_filesystem_fsmount_me_t  mount_h                              
)                                                                     
{                                                                     
  size_t fsn_size = sizeof( filesystem_node ) + strlen(type) + 1;     
  filesystem_node *fsn = malloc( fsn_size );                          
  char *type_storage = (char *) fsn + sizeof( filesystem_node );      
    a65c:	e2847010 	add	r7, r4, #16                                   
                                                                      
  if ( fsn == NULL )                                                  
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  strcpy(type_storage, type);                                         
    a660:	e1a01006 	mov	r1, r6                                        
    a664:	e1a00007 	mov	r0, r7                                        
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 );
    a668:	e59f5068 	ldr	r5, [pc, #104]	; a6d8 <rtems_filesystem_register+0xb0>
    a66c:	eb000f09 	bl	e298 <strcpy>                                  
    a670:	e3a01000 	mov	r1, #0                                        
    a674:	e1a02001 	mov	r2, r1                                        
  fsn->entry.type = type_storage;                                     
    a678:	e5847008 	str	r7, [r4, #8]                                  
  fsn->entry.mount_h = mount_h;                                       
    a67c:	e584800c 	str	r8, [r4, #12]                                 
    a680:	e5950000 	ldr	r0, [r5]                                      
    a684:	ebffeac4 	bl	519c <rtems_semaphore_obtain>                  
                                                                      
  rtems_libio_lock();                                                 
  if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {         
    a688:	e1a00006 	mov	r0, r6                                        
    a68c:	ebffffdb 	bl	a600 <rtems_filesystem_get_mount_handler>      
    a690:	e2506000 	subs	r6, r0, #0                                   
    a694:	1a000006 	bne	a6b4 <rtems_filesystem_register+0x8c>         
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
    a698:	e1a01004 	mov	r1, r4                                        
    a69c:	e59f0038 	ldr	r0, [pc, #56]	; a6dc <rtems_filesystem_register+0xb4>
    a6a0:	ebffece8 	bl	5a48 <_Chain_Append>                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
    a6a4:	e5950000 	ldr	r0, [r5]                                      
    a6a8:	ebffeb01 	bl	52b4 <rtems_semaphore_release>                 
    a6ac:	e1a00006 	mov	r0, r6                                        
                                                                      
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return 0;                                                           
    a6b0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
    a6b4:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
    a6b8:	ebffeafd 	bl	52b4 <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 );                                                      
    a6bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    a6c0:	ebffde02 	bl	1ed0 <free>                                    <== NOT EXECUTED
                                                                      
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    a6c4:	eb000b3e 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a6c8:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    a6cc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    a6d0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return 0;                                                           
}                                                                     
    a6d4:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0000a4a0 <rtems_filesystem_unregister>: int rtems_filesystem_unregister( const char *type ) {
    a4a0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
    a4a4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
    a4a8:	1a000004 	bne	a4c0 <rtems_filesystem_unregister+0x20>       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
    a4ac:	eb000bc4 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a4b0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
    a4b4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    a4b8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    a4bc:	e8bd80f0 	pop	{r4, r5, r6, r7, 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 );
    a4c0:	e59f307c 	ldr	r3, [pc, #124]	; a544 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
    a4c4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->first;                                            
    a4c8:	e59f4078 	ldr	r4, [pc, #120]	; a548 <rtems_filesystem_unregister+0xa8><== NOT EXECUTED
    a4cc:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    a4d0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    a4d4:	ebffeb30 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
    a4d8:	e4946004 	ldr	r6, [r4], #4                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
    a4dc:	ea00000d 	b	a518 <rtems_filesystem_unregister+0x78>         <== 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 ) {                     
    a4e0:	e5960008 	ldr	r0, [r6, #8]                                  <== NOT EXECUTED
    a4e4:	eb000edf 	bl	e068 <strcmp>                                  <== NOT EXECUTED
    a4e8:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    a4ec:	1a000008 	bne	a514 <rtems_filesystem_unregister+0x74>       <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
    a4f0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    a4f4:	ebffed5e 	bl	5a74 <_Chain_Extract>                          <== NOT EXECUTED
      rtems_chain_extract( node );                                    
      free( fsn );                                                    
    a4f8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    a4fc:	ebffde73 	bl	1ed0 <free>                                    <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
    a500:	e59f303c 	ldr	r3, [pc, #60]	; a544 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
    a504:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    a508:	ebffeb69 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
    a50c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
      rtems_libio_unlock();                                           
                                                                      
      return 0;                                                       
    a510:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
    a514:	e5966000 	ldr	r6, [r6]                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
    a518:	e1560004 	cmp	r6, r4                                        <== 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 ) {                     
    a51c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    a520:	1affffee 	bne	a4e0 <rtems_filesystem_unregister+0x40>       <== NOT EXECUTED
    a524:	e59f3018 	ldr	r3, [pc, #24]	; a544 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
    a528:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    a52c:	ebffeb60 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
      return 0;                                                       
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
    a530:	eb000ba3 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    a534:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
    a538:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    a53c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
    a540:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00006828 <rtems_fsmount>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
    6828:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
    682c:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
    6830:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
    6834:	e2804014 	add	r4, r0, #20                                   <== NOT EXECUTED
    6838:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
          rc = tmp_rc;                                                
        }                                                             
      }                                                               
      else {                                                          
        if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {      
          fprintf(stdout,"fsmount: mounting of \"%s\" to"             
    683c:	e59f6118 	ldr	r6, [pc, #280]	; 695c <rtems_fsmount+0x134>   <== NOT EXECUTED
    6840:	ea000036 	b	6920 <rtems_fsmount+0xf8>                       <== NOT EXECUTED
    tmp_rc = 0;                                                       
    /*                                                                
     * create mount point                                             
     */                                                               
    if (tmp_rc == 0) {                                                
      tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
    6844:	e5140010 	ldr	r0, [r4, #-16]                                <== NOT EXECUTED
    6848:	e59f1110 	ldr	r1, [pc, #272]	; 6960 <rtems_fsmount+0x138>   <== NOT EXECUTED
    684c:	eb000914 	bl	8ca4 <rtems_mkdir>                             <== NOT EXECUTED
      if (tmp_rc != 0) {                                              
    6850:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    6854:	0a000038 	beq	693c <rtems_fsmount+0x114>                    <== NOT EXECUTED
        if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
    6858:	e15430b4 	ldrh	r3, [r4, #-4]                                <== NOT EXECUTED
    685c:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
    6860:	0a00000a 	beq	6890 <rtems_fsmount+0x68>                     <== NOT EXECUTED
          fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
    6864:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    6868:	e5149010 	ldr	r9, [r4, #-16]                                <== NOT EXECUTED
    686c:	e593b008 	ldr	fp, [r3, #8]                                  <== NOT EXECUTED
    6870:	eb00d9a2 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    6874:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
    6878:	eb00f311 	bl	434c4 <strerror>                               <== NOT EXECUTED
    687c:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
    6880:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    6884:	e59f10d8 	ldr	r1, [pc, #216]	; 6964 <rtems_fsmount+0x13c>   <== NOT EXECUTED
    6888:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
    688c:	eb00dc12 	bl	3d8dc <fprintf>                                <== NOT EXECUTED
                  fstab_ptr->target,                                  
                  strerror(errno));                                   
        }                                                             
        if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
    6890:	e15430b2 	ldrh	r3, [r4, #-2]                                <== NOT EXECUTED
    6894:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
    6898:	ea000011 	b	68e4 <rtems_fsmount+0xbc>                       <== NOT EXECUTED
                     fstab_ptr->target,                               
                     fstab_ptr->type,                                 
                     fstab_ptr->options,                              
                     NULL);                                           
      if (tmp_rc != 0) {                                              
        if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {  
    689c:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
    68a0:	0a00000d 	beq	68dc <rtems_fsmount+0xb4>                     <== NOT EXECUTED
          fprintf(stdout,"fsmount: mounting of \"%s\" to"             
    68a4:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    68a8:	e5142014 	ldr	r2, [r4, #-20]                                <== NOT EXECUTED
    68ac:	e593b008 	ldr	fp, [r3, #8]                                  <== NOT EXECUTED
    68b0:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
    68b4:	e5149010 	ldr	r9, [r4, #-16]                                <== NOT EXECUTED
    68b8:	eb00d990 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    68bc:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
    68c0:	eb00f2ff 	bl	434c4 <strerror>                               <== NOT EXECUTED
    68c4:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
    68c8:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
    68cc:	e1a03009 	mov	r3, r9                                        <== NOT EXECUTED
    68d0:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
    68d4:	e59f108c 	ldr	r1, [pc, #140]	; 6968 <rtems_fsmount+0x140>   <== NOT EXECUTED
    68d8:	eb00dbff 	bl	3d8dc <fprintf>                                <== NOT EXECUTED
                  " \"%s\" failed: %s\n",                             
                  fstab_ptr->source,                                  
                  fstab_ptr->target,                                  
                  strerror(errno));                                   
        }                                                             
        if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_FAILED)) {   
    68dc:	e15430b2 	ldrh	r3, [r4, #-2]                                <== NOT EXECUTED
    68e0:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
    68e4:	0a00000b 	beq	6918 <rtems_fsmount+0xf0>                     <== NOT EXECUTED
    68e8:	ea00000f 	b	692c <rtems_fsmount+0x104>                      <== NOT EXECUTED
          terminate = true;                                           
          rc = tmp_rc;                                                
        }                                                             
      }                                                               
      else {                                                          
        if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {      
    68ec:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
    68f0:	0a000005 	beq	690c <rtems_fsmount+0xe4>                     <== NOT EXECUTED
          fprintf(stdout,"fsmount: mounting of \"%s\" to"             
    68f4:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    68f8:	e59f106c 	ldr	r1, [pc, #108]	; 696c <rtems_fsmount+0x144>   <== NOT EXECUTED
    68fc:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
    6900:	e2442014 	sub	r2, r4, #20                                   <== NOT EXECUTED
    6904:	e892000c 	ldm	r2, {r2, r3}                                  <== NOT EXECUTED
    6908:	eb00dbf3 	bl	3d8dc <fprintf>                                <== NOT EXECUTED
                  " \"%s\" succeeded\n",                              
                  fstab_ptr->source,                                  
                  fstab_ptr->target);                                 
        }                                                             
        if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_OK)) {       
    690c:	e15430b2 	ldrh	r3, [r4, #-2]                                <== NOT EXECUTED
    6910:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
    6914:	1a000003 	bne	6928 <rtems_fsmount+0x100>                    <== NOT EXECUTED
    /*                                                                
     * proceed to next entry                                          
     */                                                               
    if (!terminate) {                                                 
      fstab_ptr++;                                                    
      fstab_idx++;                                                    
    6918:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    691c:	e2844014 	add	r4, r4, #20                                   <== NOT EXECUTED
  bool terminate = false;                                             
                                                                      
  /*                                                                  
   * scan through all fstab entries;                                  
   */                                                                 
  while (!terminate &&                                                
    6920:	e155000a 	cmp	r5, sl                                        <== NOT EXECUTED
    6924:	3affffc6 	bcc	6844 <rtems_fsmount+0x1c>                     <== NOT EXECUTED
    6928:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    if (!terminate) {                                                 
      fstab_ptr++;                                                    
      fstab_idx++;                                                    
    }                                                                 
  }                                                                   
  if (fail_idx != NULL) {                                             
    692c:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
    *fail_idx = fstab_idx;                                            
    6930:	15885000 	strne	r5, [r8]                                    <== NOT EXECUTED
  }                                                                   
  return rc;                                                          
}                                                                     
    6934:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    6938:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
    }                                                                 
    /*                                                                
     * mount device to given mount point                              
     */                                                               
    if (tmp_rc == 0) {                                                
      tmp_rc = mount(fstab_ptr->source,                               
    693c:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
    6940:	e2440014 	sub	r0, r4, #20                                   <== NOT EXECUTED
    6944:	e890000f 	ldm	r0, {r0, r1, r2, r3}                          <== NOT EXECUTED
    6948:	eb0005df 	bl	80cc <mount>                                   <== NOT EXECUTED
                     fstab_ptr->target,                               
                     fstab_ptr->type,                                 
                     fstab_ptr->options,                              
                     NULL);                                           
      if (tmp_rc != 0) {                                              
    694c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    6950:	e15430b4 	ldrh	r3, [r4, #-4]                                <== NOT EXECUTED
    6954:	1affffd0 	bne	689c <rtems_fsmount+0x74>                     <== NOT EXECUTED
    6958:	eaffffe3 	b	68ec <rtems_fsmount+0xc4>                       <== NOT EXECUTED
                                                                      

00001a5c <rtems_io_lookup_name>: rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) {
    1a5c:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
    1a60:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
    1a64:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    1a68:	e1a06000 	mov	r6, r0                                        <== 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( name, strlen( name ), 0x00, &loc, true );
    1a6c:	eb003259 	bl	e3d8 <strlen>                                  <== NOT EXECUTED
    1a70:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
    1a74:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
    1a78:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    1a7c:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
    1a80:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
    1a84:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    1a88:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
    1a8c:	eb0000f1 	bl	1e58 <rtems_filesystem_evaluate_path>          <== NOT EXECUTED
  the_jnode = loc.node_access;                                        
                                                                      
  if ( !loc.ops->node_type_h ) {                                      
    1a90:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
    1a94:	e5923010 	ldr	r3, [r2, #16]                                 <== NOT EXECUTED
    1a98:	e3530000 	cmp	r3, #0                                        <== 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( name, strlen( name ), 0x00, &loc, true );
    1a9c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  the_jnode = loc.node_access;                                        
    1aa0:	e59d8004 	ldr	r8, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  if ( !loc.ops->node_type_h ) {                                      
    1aa4:	1a000009 	bne	1ad0 <rtems_io_lookup_name+0x74>              <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
    1aa8:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
    1aac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    1ab0:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    1ab4:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    1ab8:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    1abc:	eb002e40 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    1ac0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    1ac4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    1ac8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    1acc:	ea000026 	b	1b6c <rtems_io_lookup_name+0x110>               <== NOT EXECUTED
  }                                                                   
                                                                      
  node_type = (*loc.ops->node_type_h)( &loc );                        
    1ad0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    1ad4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    1ad8:	e12fff13 	bx	r3                                             <== NOT EXECUTED
                                                                      
  if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {      
    1adc:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    1ae0:	03500002 	cmpeq	r0, #2                                      <== NOT EXECUTED
    1ae4:	03a0a000 	moveq	sl, #0                                      <== NOT EXECUTED
    1ae8:	13a0a001 	movne	sl, #1                                      <== NOT EXECUTED
    1aec:	e59d7010 	ldr	r7, [sp, #16]                                 <== NOT EXECUTED
    1af0:	0a000008 	beq	1b18 <rtems_io_lookup_name+0xbc>              <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
    1af4:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    1af8:	0a000018 	beq	1b60 <rtems_io_lookup_name+0x104>             <== NOT EXECUTED
    1afc:	e597301c 	ldr	r3, [r7, #28]                                 <== NOT EXECUTED
    1b00:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    1b04:	0a000015 	beq	1b60 <rtems_io_lookup_name+0x104>             <== NOT EXECUTED
    1b08:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    1b0c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    1b10:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    1b14:	ea000011 	b	1b60 <rtems_io_lookup_name+0x104>               <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  device_info->device_name        = (char *) name;                    
    1b18:	e5856000 	str	r6, [r5]                                      <== NOT EXECUTED
  device_info->device_name_length = strlen( name );                   
    1b1c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    1b20:	eb00322c 	bl	e3d8 <strlen>                                  <== NOT EXECUTED
    1b24:	e5850004 	str	r0, [r5, #4]                                  <== NOT EXECUTED
  device_info->major              = the_jnode->info.device.major;     
    1b28:	e5983050 	ldr	r3, [r8, #80]	; 0x50                          <== NOT EXECUTED
    1b2c:	e5853008 	str	r3, [r5, #8]                                  <== NOT EXECUTED
  device_info->minor              = the_jnode->info.device.minor;     
    1b30:	e5983054 	ldr	r3, [r8, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    1b34:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  device_info->device_name        = (char *) name;                    
  device_info->device_name_length = strlen( name );                   
  device_info->major              = the_jnode->info.device.major;     
  device_info->minor              = the_jnode->info.device.minor;     
    1b38:	e585300c 	str	r3, [r5, #12]                                 <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    1b3c:	0a000009 	beq	1b68 <rtems_io_lookup_name+0x10c>             <== NOT EXECUTED
    1b40:	e597301c 	ldr	r3, [r7, #28]                                 <== NOT EXECUTED
    1b44:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    1b48:	0a000006 	beq	1b68 <rtems_io_lookup_name+0x10c>             <== NOT EXECUTED
    1b4c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    1b50:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    1b54:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    1b58:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
    1b5c:	ea000002 	b	1b6c <rtems_io_lookup_name+0x110>               <== NOT EXECUTED
    1b60:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
    1b64:	ea000000 	b	1b6c <rtems_io_lookup_name+0x110>               <== NOT EXECUTED
    1b68:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    1b6c:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
    1b70:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

00001fdc <rtems_libio_init>: * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) {
    1fdc:	e92d4011 	push	{r0, r4, lr}                                 
    rtems_status_code rc;                                             
    uint32_t i;                                                       
    rtems_libio_t *iop;                                               
                                                                      
    if (rtems_libio_number_iops > 0)                                  
    1fe0:	e59f4098 	ldr	r4, [pc, #152]	; 2080 <rtems_libio_init+0xa4> 
    1fe4:	e5940000 	ldr	r0, [r4]                                      
    1fe8:	e3500000 	cmp	r0, #0                                        
    1fec:	0a000013 	beq	2040 <rtems_libio_init+0x64>                  
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
    1ff0:	e3a01040 	mov	r1, #64	; 0x40                                
    1ff4:	ebffff2d 	bl	1cb0 <calloc>                                  
    1ff8:	e59f3084 	ldr	r3, [pc, #132]	; 2084 <rtems_libio_init+0xa8> 
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
    1ffc:	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,
    2000:	e5830000 	str	r0, [r3]                                      
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
    2004:	0280001a 	addeq	r0, r0, #26                                 
                                                                      
    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)                                 
    2008:	0a000015 	beq	2064 <rtems_libio_init+0x88>                  
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
    200c:	e59f3074 	ldr	r3, [pc, #116]	; 2088 <rtems_libio_init+0xac> 
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
    2010:	e5941000 	ldr	r1, [r4]                                      
        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;            
    2014:	e5830000 	str	r0, [r3]                                      
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
    2018:	e3a03000 	mov	r3, #0                                        
    201c:	ea000000 	b	2024 <rtems_libio_init+0x48>                    
          iop->data1 = iop + 1;                                       
    2020:	e500000c 	str	r0, [r0, #-12]                                
                                                    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++)  
    2024:	e2833001 	add	r3, r3, #1                                    
    2028:	e1530001 	cmp	r3, r1                                        
          iop->data1 = iop + 1;                                       
    202c:	e1a02000 	mov	r2, r0                                        
                                                    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++)  
    2030:	e2800040 	add	r0, r0, #64	; 0x40                            
    2034:	3afffff9 	bcc	2020 <rtems_libio_init+0x44>                  
          iop->data1 = iop + 1;                                       
        iop->data1 = NULL;                                            
    2038:	e3a03000 	mov	r3, #0                                        
    203c:	e5823034 	str	r3, [r2, #52]	; 0x34                          
  /*                                                                  
   *  Create the binary semaphore used to provide mutual exclusion    
   *  on the IOP Table.                                               
   */                                                                 
                                                                      
  rc = rtems_semaphore_create(                                        
    2040:	e59fc044 	ldr	ip, [pc, #68]	; 208c <rtems_libio_init+0xb0>  
    2044:	e59f0044 	ldr	r0, [pc, #68]	; 2090 <rtems_libio_init+0xb4>  
    2048:	e3a01001 	mov	r1, #1                                        
    204c:	e3a02054 	mov	r2, #84	; 0x54                                
    2050:	e3a03000 	mov	r3, #0                                        
    2054:	e58dc000 	str	ip, [sp]                                      
    2058:	eb000bbd 	bl	4f54 <rtems_semaphore_create>                  
    1,                                                                
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
    205c:	e3500000 	cmp	r0, #0                                        
    2060:	0a000000 	beq	2068 <rtems_libio_init+0x8c>                  
    rtems_fatal_error_occurred( rc );                                 
    2064:	eb000dcf 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  if (rtems_fs_init_helper)                                           
    2068:	e59f3024 	ldr	r3, [pc, #36]	; 2094 <rtems_libio_init+0xb8>  
    206c:	e5933000 	ldr	r3, [r3]                                      
    2070:	e3530000 	cmp	r3, #0                                        
     (* rtems_fs_init_helper)();                                      
    2074:	11a0e00f 	movne	lr, pc                                      
    2078:	112fff13 	bxne	r3                                           
}                                                                     
    207c:	e8bd8018 	pop	{r3, r4, pc}                                  
                                                                      

000265f0 <rtems_libio_set_private_env>: rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) {
   265f0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  rtems_status_code 					sc;                                          
  rtems_id          					task_id;                                     
  rtems_filesystem_location_info_t		loc;                              
                                                                      
  sc=rtems_task_ident(RTEMS_SELF,0,&task_id);                         
   265f4:	e3a00000 	mov	r0, #0                                        
		rtems_filesystem_freenode( &env->root_directory);                   
		free(env);                                                          
	}                                                                    
}                                                                     
                                                                      
rtems_status_code rtems_libio_set_private_env(void) {                 
   265f8:	e24dd01c 	sub	sp, sp, #28                                   
  rtems_status_code 					sc;                                          
  rtems_id          					task_id;                                     
  rtems_filesystem_location_info_t		loc;                              
                                                                      
  sc=rtems_task_ident(RTEMS_SELF,0,&task_id);                         
   265fc:	e1a01000 	mov	r1, r0                                        
   26600:	e28d2018 	add	r2, sp, #24                                   
   26604:	eb000470 	bl	277cc <rtems_task_ident>                       
  if (sc != RTEMS_SUCCESSFUL) return sc;                              
   26608:	e2508000 	subs	r8, r0, #0                                   
   2660c:	1a000037 	bne	266f0 <rtems_libio_set_private_env+0x100>     
                                                                      
  /* Only for the first time a malloc is necesary */                  
  if (rtems_current_user_env==&rtems_global_user_env) {               
   26610:	e59f40e4 	ldr	r4, [pc, #228]	; 266fc <rtems_libio_set_private_env+0x10c>
   26614:	e59f30e4 	ldr	r3, [pc, #228]	; 26700 <rtems_libio_set_private_env+0x110>
   26618:	e5942000 	ldr	r2, [r4]                                      
   2661c:	e1520003 	cmp	r2, r3                                        
   26620:	1a00000f 	bne	26664 <rtems_libio_set_private_env+0x74>      
   rtems_user_env_t	*tmp = malloc(sizeof(rtems_user_env_t));          
   26624:	e2800048 	add	r0, r0, #72	; 0x48                            
   26628:	ebff85c8 	bl	7d50 <malloc>                                  
   if (!tmp)                                                          
   2662c:	e2505000 	subs	r5, r0, #0                                   
   26630:	03a0801a 	moveq	r8, #26                                     
   26634:	0a00002d 	beq	266f0 <rtems_libio_set_private_env+0x100>     
                                                                      
#ifdef HAVE_USERENV_REFCNT                                            
   tmp->refcnt = 1;                                                   
#endif                                                                
                                                                      
   sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env);
   26638:	e1a00008 	mov	r0, r8                                        
   2663c:	e1a01004 	mov	r1, r4                                        
   26640:	e59f20bc 	ldr	r2, [pc, #188]	; 26704 <rtems_libio_set_private_env+0x114>
   26644:	eb000500 	bl	27a4c <rtems_task_variable_add>                
   if (sc != RTEMS_SUCCESSFUL) {                                      
   26648:	e2506000 	subs	r6, r0, #0                                   
	  * not initialized yet                                              
	  */                                                                 
     free(tmp);                                                       
     return sc;                                                       
   }                                                                  
   rtems_current_user_env = tmp;                                      
   2664c:	05845000 	streq	r5, [r4]                                    
#ifdef HAVE_USERENV_REFCNT                                            
   tmp->refcnt = 1;                                                   
#endif                                                                
                                                                      
   sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env);
   if (sc != RTEMS_SUCCESSFUL) {                                      
   26650:	0a000003 	beq	26664 <rtems_libio_set_private_env+0x74>      
	 /* don't use free_user_env because the pathlocs are                 
	  * not initialized yet                                              
	  */                                                                 
     free(tmp);                                                       
   26654:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   26658:	ebff8415 	bl	76b4 <free>                                    <== NOT EXECUTED
   2665c:	e1a08006 	mov	r8, r6                                        <== NOT EXECUTED
     return sc;                                                       
   26660:	ea000022 	b	266f0 <rtems_libio_set_private_env+0x100>       <== NOT EXECUTED
   }                                                                  
   rtems_current_user_env = tmp;                                      
  };                                                                  
                                                                      
  *rtems_current_user_env = rtems_global_user_env; /* get the global values*/
   26664:	e59f6090 	ldr	r6, [pc, #144]	; 266fc <rtems_libio_set_private_env+0x10c>
   26668:	e5967000 	ldr	r7, [r6]                                      
   2666c:	e59f108c 	ldr	r1, [pc, #140]	; 26700 <rtems_libio_set_private_env+0x110>
   26670:	e3a02048 	mov	r2, #72	; 0x48                                
   26674:	e1a00007 	mov	r0, r7                                        
   26678:	eb0066d0 	bl	401c0 <memcpy>                                 
  rtems_current_user_env->task_id=task_id;         /* mark the local values*/
   2667c:	e59d3018 	ldr	r3, [sp, #24]                                 
   * 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_evaluate_path("/", 1, 0, &loc, 0);                 
   26680:	e28d4004 	add	r4, sp, #4                                    
   26684:	e3a05000 	mov	r5, #0                                        
   }                                                                  
   rtems_current_user_env = tmp;                                      
  };                                                                  
                                                                      
  *rtems_current_user_env = rtems_global_user_env; /* get the global values*/
  rtems_current_user_env->task_id=task_id;         /* mark the local values*/
   26688:	e5873000 	str	r3, [r7]                                      
   * 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_evaluate_path("/", 1, 0, &loc, 0);                 
   2668c:	e3a01001 	mov	r1, #1                                        
   26690:	e1a03004 	mov	r3, r4                                        
   26694:	e1a02005 	mov	r2, r5                                        
   26698:	e59f0068 	ldr	r0, [pc, #104]	; 26708 <rtems_libio_set_private_env+0x118>
  rtems_filesystem_root    = loc;                                     
   2669c:	e1a07004 	mov	r7, r4                                        
   * 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_evaluate_path("/", 1, 0, &loc, 0);                 
   266a0:	e58d5000 	str	r5, [sp]                                      
   266a4:	ebff83e4 	bl	763c <rtems_filesystem_evaluate_path>          
  rtems_filesystem_root    = loc;                                     
   266a8:	e596c000 	ldr	ip, [r6]                                      
   266ac:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         
   266b0:	e28cc018 	add	ip, ip, #24                                   
   266b4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
   266b8:	e5973000 	ldr	r3, [r7]                                      
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
   266bc:	e1a02005 	mov	r2, r5                                        
   * clones. The reason is a pathloc can be allocated by the          
   * file system and needs to be freed when deleting the environment. 
   */                                                                 
                                                                      
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
  rtems_filesystem_root    = loc;                                     
   266c0:	e58c3000 	str	r3, [ip]                                      
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
   266c4:	e3a01001 	mov	r1, #1                                        
   266c8:	e1a03004 	mov	r3, r4                                        
   266cc:	e59f0034 	ldr	r0, [pc, #52]	; 26708 <rtems_libio_set_private_env+0x118>
   266d0:	e58d5000 	str	r5, [sp]                                      
   266d4:	ebff83d8 	bl	763c <rtems_filesystem_evaluate_path>          
  rtems_filesystem_current = loc;                                     
   266d8:	e596c000 	ldr	ip, [r6]                                      
   266dc:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         
   266e0:	e28cc004 	add	ip, ip, #4                                    
   266e4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
   266e8:	e5973000 	ldr	r3, [r7]                                      
   266ec:	e58c3000 	str	r3, [ip]                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   266f0:	e1a00008 	mov	r0, r8                                        
   266f4:	e28dd01c 	add	sp, sp, #28                                   
   266f8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

0002654c <rtems_libio_share_private_env>: * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ #ifndef HAVE_USERENV_REFCNT rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
   2654c:	e92d4033 	push	{r0, r1, r4, r5, lr}                         <== NOT EXECUTED
   26550:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  rtems_status_code  sc;                                              
  rtems_user_env_t * shared_user_env;                                 
  rtems_id           current_task_id;                                 
                                                                      
  sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id);                 
   26554:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   26558:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   2655c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   26560:	eb000499 	bl	277cc <rtems_task_ident>                       <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) return sc;                              
   26564:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   26568:	1a00001b 	bne	265dc <rtems_libio_share_private_env+0x90>    <== NOT EXECUTED
                                                                      
  if (rtems_current_user_env->task_id==current_task_id) {             
   2656c:	e59f1070 	ldr	r1, [pc, #112]	; 265e4 <rtems_libio_share_private_env+0x98><== NOT EXECUTED
   26570:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
   26574:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   26578:	e5942000 	ldr	r2, [r4]                                      <== NOT EXECUTED
   2657c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   26580:	1a000004 	bne	26598 <rtems_libio_share_private_env+0x4c>    <== NOT EXECUTED
   /* kill the current user env & task_var*/                          
	rtems_user_env_t 	*tmp = rtems_current_user_env;                     
   sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env);
   26584:	eb000559 	bl	27af0 <rtems_task_variable_delete>             <== NOT EXECUTED
   if (sc != RTEMS_SUCCESSFUL) return sc;                             
   26588:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   2658c:	1a000012 	bne	265dc <rtems_libio_share_private_env+0x90>    <== NOT EXECUTED
   free_user_env(tmp);                                                
   26590:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   26594:	ebffffd3 	bl	264e8 <free_user_env>                          <== NOT EXECUTED
  };                                                                  
                                                                      
  /* AT THIS POINT, rtems_current_user_env is DANGLING */             
                                                                      
  sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env,
   26598:	e59f4044 	ldr	r4, [pc, #68]	; 265e4 <rtems_libio_share_private_env+0x98><== NOT EXECUTED
   2659c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   265a0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   265a4:	e28d2004 	add	r2, sp, #4                                    <== NOT EXECUTED
   265a8:	eb00056d 	bl	27b64 <rtems_task_variable_get>                <== NOT EXECUTED
		                       (void*)&shared_user_env       );             
  if (sc != RTEMS_SUCCESSFUL)                                         
   265ac:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   265b0:	1a000006 	bne	265d0 <rtems_libio_share_private_env+0x84>    <== NOT EXECUTED
    goto bailout;                                                     
                                                                      
  sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
   265b4:	e59f202c 	ldr	r2, [pc, #44]	; 265e8 <rtems_libio_share_private_env+0x9c><== NOT EXECUTED
   265b8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   265bc:	eb000522 	bl	27a4c <rtems_task_variable_add>                <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
   265c0:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    goto bailout;                                                     
                                                                      
  /* the current_user_env is the same pointer that remote env */      
  rtems_current_user_env = shared_user_env;                           
   265c4:	059d2004 	ldreq	r2, [sp, #4]                                <== NOT EXECUTED
   265c8:	05842000 	streq	r2, [r4]                                    <== NOT EXECUTED
		                       (void*)&shared_user_env       );             
  if (sc != RTEMS_SUCCESSFUL)                                         
    goto bailout;                                                     
                                                                      
  sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
  if (sc != RTEMS_SUCCESSFUL)                                         
   265cc:	0a000002 	beq	265dc <rtems_libio_share_private_env+0x90>    <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
                                                                      
bailout:                                                              
  /* fallback to the global env */                                    
  rtems_current_user_env = &rtems_global_user_env;                    
   265d0:	e59f1014 	ldr	r1, [pc, #20]	; 265ec <rtems_libio_share_private_env+0xa0><== NOT EXECUTED
   265d4:	e59f2008 	ldr	r2, [pc, #8]	; 265e4 <rtems_libio_share_private_env+0x98><== NOT EXECUTED
   265d8:	e5821000 	str	r1, [r2]                                      <== NOT EXECUTED
  return sc;                                                          
}                                                                     
   265dc:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   265e0:	e8bd803c 	pop	{r2, r3, r4, r5, pc}                          <== NOT EXECUTED
                                                                      

00007e48 <rtems_malloc_statistics_at_free>: * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) {
    7e48:	e92d4801 	push	{r0, fp, lr}                                 <== NOT EXECUTED
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
    7e4c:	e59f3038 	ldr	r3, [pc, #56]	; 7e8c <rtems_malloc_statistics_at_free+0x44><== NOT EXECUTED
 *  size and thus we skip updating the statistics.                    
 */                                                                   
static void rtems_malloc_statistics_at_free(                          
  void *pointer                                                       
)                                                                     
{                                                                     
    7e50:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
    7e54:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
    7e58:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    7e5c:	eb0015ce 	bl	d59c <_Protected_heap_Get_block_size>          <== NOT EXECUTED
    7e60:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    7e64:	0a000007 	beq	7e88 <rtems_malloc_statistics_at_free+0x40>   <== NOT EXECUTED
    MSBUMP(lifetime_freed, size);                                     
    7e68:	e59f3020 	ldr	r3, [pc, #32]	; 7e90 <rtems_malloc_statistics_at_free+0x48><== NOT EXECUTED
    7e6c:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
    7e70:	e283c024 	add	ip, r3, #36	; 0x24                            <== NOT EXECUTED
    7e74:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
    7e78:	e09b1000 	adds	r1, fp, r0                                   <== NOT EXECUTED
    7e7c:	e2ac2000 	adc	r2, ip, #0                                    <== NOT EXECUTED
    7e80:	e5831024 	str	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
    7e84:	e5832028 	str	r2, [r3, #40]	; 0x28                          <== NOT EXECUTED
  }                                                                   
}                                                                     
    7e88:	e8bd8808 	pop	{r3, fp, pc}                                  <== NOT EXECUTED
                                                                      

00008ca4 <rtems_mkdir>: return (retval); } int rtems_mkdir(const char *path, mode_t mode) {
    8ca4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
    8ca8:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
    8cac:	e1a0b001 	mov	fp, r1                                        <== NOT EXECUTED
	int success = 0;                                                     
	char *dup_path = strdup(path);                                       
    8cb0:	eb00e9ef 	bl	43474 <strdup>                                 <== NOT EXECUTED
                                                                      
	if (dup_path != NULL) {                                              
    8cb4:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
    8cb8:	0a000057 	beq	8e1c <rtems_mkdir+0x178>                      <== NOT EXECUTED
	char *p;                                                             
                                                                      
	p = path;                                                            
	oumask = 0;                                                          
	retval = 1;                                                          
	if (p[0] == '/')		/* Skip leading '/'. */                            
    8cbc:	e5d63000 	ldrb	r3, [r6]                                     <== NOT EXECUTED
		++p;                                                                
    8cc0:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
	char *p;                                                             
                                                                      
	p = path;                                                            
	oumask = 0;                                                          
	retval = 1;                                                          
	if (p[0] == '/')		/* Skip leading '/'. */                            
    8cc4:	e353002f 	cmp	r3, #47	; 0x2f                                <== NOT EXECUTED
    8cc8:	11a05006 	movne	r5, r6                                      <== NOT EXECUTED
		++p;                                                                
    8ccc:	02865001 	addeq	r5, r6, #1                                  <== NOT EXECUTED
    8cd0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
	for (first = 1, last = 0; !last ; ++p) {                             
		if (p[0] == '\0')                                                   
			last = 1;                                                          
		else if (p[0] != '/')                                               
			continue;                                                          
		*p = '\0';                                                          
    8cd4:	e1a09007 	mov	r9, r7                                        <== NOT EXECUTED
				retval = 0;                                                       
				break;                                                            
			}                                                                  
		}                                                                   
		if (!last)                                                          
		    *p = '/';                                                       
    8cd8:	e3a0a02f 	mov	sl, #47	; 0x2f                                <== 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) {                                        
    8cdc:	e1a0800d 	mov	r8, sp                                        <== NOT EXECUTED
	oumask = 0;                                                          
	retval = 1;                                                          
	if (p[0] == '/')		/* Skip leading '/'. */                            
		++p;                                                                
	for (first = 1, last = 0; !last ; ++p) {                             
		if (p[0] == '\0')                                                   
    8ce0:	e5d52000 	ldrb	r2, [r5]                                     <== NOT EXECUTED
    8ce4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    8ce8:	02822001 	addeq	r2, r2, #1                                  <== NOT EXECUTED
    8cec:	0a000002 	beq	8cfc <rtems_mkdir+0x58>                       <== NOT EXECUTED
			last = 1;                                                          
		else if (p[0] != '/')                                               
    8cf0:	e352002f 	cmp	r2, #47	; 0x2f                                <== NOT EXECUTED
    8cf4:	1a00003c 	bne	8dec <rtems_mkdir+0x148>                      <== NOT EXECUTED
    8cf8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
			continue;                                                          
		*p = '\0';                                                          
		if (!last && p[1] == '\0')                                          
    8cfc:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
	for (first = 1, last = 0; !last ; ++p) {                             
		if (p[0] == '\0')                                                   
			last = 1;                                                          
		else if (p[0] != '/')                                               
			continue;                                                          
		*p = '\0';                                                          
    8d00:	e5c59000 	strb	r9, [r5]                                     <== NOT EXECUTED
		if (!last && p[1] == '\0')                                          
    8d04:	13a04001 	movne	r4, #1                                      <== NOT EXECUTED
    8d08:	1a000002 	bne	8d18 <rtems_mkdir+0x74>                       <== NOT EXECUTED
    8d0c:	e5d54001 	ldrb	r4, [r5, #1]                                 <== NOT EXECUTED
    8d10:	e2744001 	rsbs	r4, r4, #1                                   <== NOT EXECUTED
    8d14:	33a04000 	movcc	r4, #0                                      <== NOT EXECUTED
			last = 1;                                                          
		if (first) {                                                        
    8d18:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8d1c:	0a000004 	beq	8d34 <rtems_mkdir+0x90>                       <== NOT EXECUTED
			 *    mkdir [-m mode] dir                                          
			 *                                                                 
			 * We change the user's umask and then restore it,                 
			 * instead of doing chmod's.                                       
			 */                                                                
			oumask = umask(0);                                                 
    8d20:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    8d24:	eb000755 	bl	aa80 <umask>                                   <== NOT EXECUTED
    8d28:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
			numask = oumask & ~(S_IWUSR | S_IXUSR);                            
			(void)umask(numask);                                               
    8d2c:	e3c000c0 	bic	r0, r0, #192	; 0xc0                           <== NOT EXECUTED
    8d30:	eb000752 	bl	aa80 <umask>                                   <== NOT EXECUTED
			first = 0;                                                         
		}                                                                   
		if (last)                                                           
    8d34:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    8d38:	059f10f0 	ldreq	r1, [pc, #240]	; 8e30 <rtems_mkdir+0x18c>   <== NOT EXECUTED
    8d3c:	0a000002 	beq	8d4c <rtems_mkdir+0xa8>                       <== NOT EXECUTED
			(void)umask(oumask);                                               
    8d40:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    8d44:	eb00074d 	bl	aa80 <umask>                                   <== NOT EXECUTED
    8d48:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
		if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {  
    8d4c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    8d50:	ebfffc6e 	bl	7f10 <mkdir>                                   <== NOT EXECUTED
    8d54:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8d58:	aa00001f 	bge	8ddc <rtems_mkdir+0x138>                      <== NOT EXECUTED
			if (errno == EEXIST || errno == EISDIR) {                          
    8d5c:	eb00d067 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    8d60:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
    8d64:	e3530011 	cmp	r3, #17                                       <== NOT EXECUTED
    8d68:	0a000003 	beq	8d7c <rtems_mkdir+0xd8>                       <== NOT EXECUTED
    8d6c:	eb00d063 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    8d70:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
    8d74:	e3530015 	cmp	r3, #21                                       <== NOT EXECUTED
    8d78:	1a00001d 	bne	8df4 <rtems_mkdir+0x150>                      <== NOT EXECUTED
				if (stat(path, &sb) < 0) {                                        
    8d7c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    8d80:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
    8d84:	eb00002a 	bl	8e34 <stat>                                    <== NOT EXECUTED
    8d88:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    8d8c:	ba000018 	blt	8df4 <rtems_mkdir+0x150>                      <== NOT EXECUTED
					retval = 0;                                                      
					break;                                                           
				} else if (!S_ISDIR(sb.st_mode)) {                                
    8d90:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
    8d94:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
    8d98:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
    8d9c:	0a00000a 	beq	8dcc <rtems_mkdir+0x128>                      <== NOT EXECUTED
					if (last)                                                        
    8da0:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    8da4:	0a000004 	beq	8dbc <rtems_mkdir+0x118>                      <== NOT EXECUTED
						errno = EEXIST;                                                 
    8da8:	eb00d054 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    8dac:	e3a03011 	mov	r3, #17                                       <== NOT EXECUTED
    8db0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    8db4:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    8db8:	ea000012 	b	8e08 <rtems_mkdir+0x164>                        <== NOT EXECUTED
					else                                                             
						errno = ENOTDIR;                                                
    8dbc:	eb00d04f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    8dc0:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
    8dc4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    8dc8:	ea00000c 	b	8e00 <rtems_mkdir+0x15c>                        <== NOT EXECUTED
					retval = 0;                                                      
					break;                                                           
				}                                                                 
				if (last)                                                         
    8dcc:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    8dd0:	0a000003 	beq	8de4 <rtems_mkdir+0x140>                      <== NOT EXECUTED
    8dd4:	e3a04002 	mov	r4, #2                                        <== NOT EXECUTED
    8dd8:	ea00000a 	b	8e08 <rtems_mkdir+0x164>                        <== NOT EXECUTED
			} else {                                                           
				retval = 0;                                                       
				break;                                                            
			}                                                                  
		}                                                                   
		if (!last)                                                          
    8ddc:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    8de0:	1a000010 	bne	8e28 <rtems_mkdir+0x184>                      <== NOT EXECUTED
		    *p = '/';                                                       
    8de4:	e5c5a000 	strb	sl, [r5]                                     <== NOT EXECUTED
    8de8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
	p = path;                                                            
	oumask = 0;                                                          
	retval = 1;                                                          
	if (p[0] == '/')		/* Skip leading '/'. */                            
		++p;                                                                
	for (first = 1, last = 0; !last ; ++p) {                             
    8dec:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    8df0:	eaffffba 	b	8ce0 <rtems_mkdir+0x3c>                         <== NOT EXECUTED
			}                                                                  
		}                                                                   
		if (!last)                                                          
		    *p = '/';                                                       
	}                                                                    
	if (!first && !last)                                                 
    8df4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
	p = path;                                                            
	oumask = 0;                                                          
	retval = 1;                                                          
	if (p[0] == '/')		/* Skip leading '/'. */                            
		++p;                                                                
	for (first = 1, last = 0; !last ; ++p) {                             
    8df8:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
			}                                                                  
		}                                                                   
		if (!last)                                                          
		    *p = '/';                                                       
	}                                                                    
	if (!first && !last)                                                 
    8dfc:	1a000001 	bne	8e08 <rtems_mkdir+0x164>                      <== NOT EXECUTED
		(void)umask(oumask);                                                
    8e00:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    8e04:	eb00071d 	bl	aa80 <umask>                                   <== NOT EXECUTED
	int success = 0;                                                     
	char *dup_path = strdup(path);                                       
                                                                      
	if (dup_path != NULL) {                                              
		success = build(dup_path, mode);                                    
		free(dup_path);                                                     
    8e08:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    8e0c:	ebfffa28 	bl	76b4 <free>                                    <== NOT EXECUTED
	}                                                                    
                                                                      
	return success != 0 ? 0 : -1;                                        
    8e10:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    8e14:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
    8e18:	1a000000 	bne	8e20 <rtems_mkdir+0x17c>                      <== NOT EXECUTED
    8e1c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
    8e20:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
    8e24:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
	if (dup_path != NULL) {                                              
		success = build(dup_path, mode);                                    
		free(dup_path);                                                     
	}                                                                    
                                                                      
	return success != 0 ? 0 : -1;                                        
    8e28:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
    8e2c:	eafffff5 	b	8e08 <rtems_mkdir+0x164>                        <== NOT EXECUTED
                                                                      

0001dbb0 <rtems_nvdisk_crc16_gen_factors>: * @relval RTEMS_SUCCESSFUL The table was generated. * @retval RTEMS_NO_MEMORY The table could not be allocated from the heap. */ rtems_status_code rtems_nvdisk_crc16_gen_factors (uint16_t pattern) {
   1dbb0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   1dbb4:	e1a04800 	lsl	r4, r0, #16                                   <== NOT EXECUTED
  uint32_t b;                                                         
                                                                      
  rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);       
   1dbb8:	e3a00c02 	mov	r0, #512	; 0x200                              <== NOT EXECUTED
   1dbbc:	ebffa863 	bl	7d50 <malloc>                                  <== NOT EXECUTED
   1dbc0:	e59f3054 	ldr	r3, [pc, #84]	; 1dc1c <rtems_nvdisk_crc16_gen_factors+0x6c><== NOT EXECUTED
  if (!rtems_nvdisk_crc16_factor)                                     
   1dbc4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
rtems_status_code                                                     
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)                     
{                                                                     
  uint32_t b;                                                         
                                                                      
  rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);       
   1dbc8:	e5830008 	str	r0, [r3, #8]                                  <== NOT EXECUTED
 * @relval RTEMS_SUCCESSFUL The table was generated.                  
 * @retval RTEMS_NO_MEMORY The table could not be allocated from the heap.
 */                                                                   
rtems_status_code                                                     
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)                     
{                                                                     
   1dbcc:	e1a04824 	lsr	r4, r4, #16                                   <== NOT EXECUTED
  uint32_t b;                                                         
                                                                      
  rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);       
  if (!rtems_nvdisk_crc16_factor)                                     
   1dbd0:	0280001a 	addeq	r0, r0, #26                                 <== NOT EXECUTED
   1dbd4:	08bd8010 	popeq	{r4, pc}                                    <== NOT EXECUTED
   1dbd8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   1dbdc:	e1a02803 	lsl	r2, r3, #16                                   <== NOT EXECUTED
   1dbe0:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
   1dbe4:	e3a01008 	mov	r1, #8                                        <== NOT EXECUTED
                                                                      
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
   1dbe8:	ea000002 	b	1dbf8 <rtems_nvdisk_crc16_gen_factors+0x48>     <== NOT EXECUTED
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
   1dbec:	e3120001 	tst	r2, #1                                        <== NOT EXECUTED
   1dbf0:	e1a020a2 	lsr	r2, r2, #1                                    <== NOT EXECUTED
   1dbf4:	10222004 	eorne	r2, r2, r4                                  <== NOT EXECUTED
                                                                      
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
   1dbf8:	e2511001 	subs	r1, r1, #1                                   <== NOT EXECUTED
   1dbfc:	2afffffa 	bcs	1dbec <rtems_nvdisk_crc16_gen_factors+0x3c>   <== NOT EXECUTED
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
    rtems_nvdisk_crc16_factor[b] = v & 0xffff;                        
   1dc00:	e1a01083 	lsl	r1, r3, #1                                    <== NOT EXECUTED
                                                                      
  rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);       
  if (!rtems_nvdisk_crc16_factor)                                     
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (b = 0; b < 256; b++)                                           
   1dc04:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   1dc08:	e3530c01 	cmp	r3, #256	; 0x100                              <== NOT EXECUTED
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
    rtems_nvdisk_crc16_factor[b] = v & 0xffff;                        
   1dc0c:	e18020b1 	strh	r2, [r0, r1]                                 <== NOT EXECUTED
                                                                      
  rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);       
  if (!rtems_nvdisk_crc16_factor)                                     
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (b = 0; b < 256; b++)                                           
   1dc10:	1afffff1 	bne	1dbdc <rtems_nvdisk_crc16_gen_factors+0x2c>   <== NOT EXECUTED
   1dc14:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
    rtems_nvdisk_crc16_factor[b] = v & 0xffff;                        
  }                                                                   
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   1dc18:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

0001d540 <rtems_nvdisk_error>: * @param ... The arguments for the format text. * @return int The number of bytes written to the output. */ static int rtems_nvdisk_error (const char *format, ...) {
   1d540:	e92d000f 	push	{r0, r1, r2, r3}                             <== NOT EXECUTED
   1d544:	e92d4031 	push	{r0, r4, r5, lr}                             <== NOT EXECUTED
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "nvdisk:error:");                                  
   1d548:	e59f4058 	ldr	r4, [pc, #88]	; 1d5a8 <rtems_nvdisk_error+0x68><== NOT EXECUTED
   1d54c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   1d550:	e59f0054 	ldr	r0, [pc, #84]	; 1d5ac <rtems_nvdisk_error+0x6c><== NOT EXECUTED
   1d554:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
static int                                                            
rtems_nvdisk_error (const char *format, ...)                          
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
   1d558:	e28d3014 	add	r3, sp, #20                                   <== NOT EXECUTED
   1d55c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  fprintf (stderr, "nvdisk:error:");                                  
   1d560:	eb00813e 	bl	3da60 <fputs>                                  <== NOT EXECUTED
  ret =  vfprintf (stderr, format, args);                             
   1d564:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   1d568:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   1d56c:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   1d570:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
   1d574:	eb00b97e 	bl	4bb74 <vfprintf>                               <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
   1d578:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "nvdisk:error:");                                  
  ret =  vfprintf (stderr, format, args);                             
   1d57c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
   1d580:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
   1d584:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
   1d588:	eb0080ef 	bl	3d94c <fputc>                                  <== NOT EXECUTED
  fflush (stderr);                                                    
   1d58c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   1d590:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
   1d594:	eb007f4c 	bl	3d2cc <fflush>                                 <== NOT EXECUTED
  va_end (args);                                                      
  return ret;                                                         
}                                                                     
   1d598:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d59c:	e8bd4038 	pop	{r3, r4, r5, lr}                              <== NOT EXECUTED
   1d5a0:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   1d5a4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001d5b0 <rtems_nvdisk_get_device>: /** * Map a block to a device. */ static rtems_nvdisk_device_ctl* rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block) {
   1d5b0:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
  uint32_t device;                                                    
                                                                      
  if (block >= nvd->block_count)                                      
   1d5b4:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
   1d5b8:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
/**                                                                   
 * Map a block to a device.                                           
 */                                                                   
static rtems_nvdisk_device_ctl*                                       
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)           
{                                                                     
   1d5bc:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_error ("read-block: bad block: %d", block);          
    return NULL;                                                      
  }                                                                   
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
   1d5c0:	33a01000 	movcc	r1, #0                                      <== NOT EXECUTED
/**                                                                   
 * Map a block to a device.                                           
 */                                                                   
static rtems_nvdisk_device_ctl*                                       
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)           
{                                                                     
   1d5c4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_error ("read-block: bad block: %d", block);          
    return NULL;                                                      
  }                                                                   
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
   1d5c8:	31a0c001 	movcc	ip, r1                                      <== NOT EXECUTED
   1d5cc:	35925018 	ldrcc	r5, [r2, #24]                               <== NOT EXECUTED
static rtems_nvdisk_device_ctl*                                       
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)           
{                                                                     
  uint32_t device;                                                    
                                                                      
  if (block >= nvd->block_count)                                      
   1d5d0:	3a000010 	bcc	1d618 <rtems_nvdisk_get_device+0x68>          <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_error ("read-block: bad block: %d", block);          
   1d5d4:	e59f0058 	ldr	r0, [pc, #88]	; 1d634 <rtems_nvdisk_get_device+0x84><== NOT EXECUTED
   1d5d8:	ebffffd8 	bl	1d540 <rtems_nvdisk_error>                     <== NOT EXECUTED
   1d5dc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
   1d5e0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  }                                                                   
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
   1d5e4:	e5920014 	ldr	r0, [r2, #20]                                 <== NOT EXECUTED
   1d5e8:	e0800001 	add	r0, r0, r1                                    <== NOT EXECUTED
    if ((block >= dc->block_base) &&                                  
   1d5ec:	e590400c 	ldr	r4, [r0, #12]                                 <== NOT EXECUTED
   1d5f0:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
   1d5f4:	3a000005 	bcc	1d610 <rtems_nvdisk_get_device+0x60>          <== NOT EXECUTED
        (block < (dc->block_base + dc->pages - dc->pages_desc)))      
   1d5f8:	e5907004 	ldr	r7, [r0, #4]                                  <== NOT EXECUTED
   1d5fc:	e5906008 	ldr	r6, [r0, #8]                                  <== NOT EXECUTED
   1d600:	e0844007 	add	r4, r4, r7                                    <== NOT EXECUTED
   1d604:	e0664004 	rsb	r4, r6, r4                                    <== NOT EXECUTED
   1d608:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
   1d60c:	38bd80f0 	popcc	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_error ("read-block: bad block: %d", block);          
    return NULL;                                                      
  }                                                                   
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
   1d610:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
   1d614:	e2811014 	add	r1, r1, #20                                   <== NOT EXECUTED
   1d618:	e15c0005 	cmp	ip, r5                                        <== NOT EXECUTED
   1d61c:	3afffff0 	bcc	1d5e4 <rtems_nvdisk_get_device+0x34>          <== NOT EXECUTED
    if ((block >= dc->block_base) &&                                  
        (block < (dc->block_base + dc->pages - dc->pages_desc)))      
      return dc;                                                      
  }                                                                   
                                                                      
  rtems_nvdisk_error ("map-block:%d: no device/page map found", block);
   1d620:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   1d624:	e59f000c 	ldr	r0, [pc, #12]	; 1d638 <rtems_nvdisk_get_device+0x88><== NOT EXECUTED
   1d628:	ebffffc4 	bl	1d540 <rtems_nvdisk_error>                     <== NOT EXECUTED
   1d62c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return NULL;                                                        
}                                                                     
   1d630:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

0001dc20 <rtems_nvdisk_initialize>: */ rtems_device_driver rtems_nvdisk_initialize (rtems_device_major_number major, rtems_device_minor_number minor, void* arg __attribute__((unused))) {
   1dc20:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   1dc24:	e24dd038 	sub	sp, sp, #56	; 0x38                            <== NOT EXECUTED
   1dc28:	e58d0018 	str	r0, [sp, #24]                                 <== NOT EXECUTED
  const rtems_nvdisk_config* c = rtems_nvdisk_configuration;          
  rtems_nvdisk*              nvd;                                     
  rtems_status_code          sc;                                      
                                                                      
  sc = rtems_disk_io_initialize ();                                   
   1dc2c:	ebffa123 	bl	60c0 <rtems_disk_io_initialize>                <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
   1dc30:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   1dc34:	1a000080 	bne	1de3c <rtems_nvdisk_initialize+0x21c>         <== NOT EXECUTED
    return sc;                                                        
                                                                      
  sc = rtems_nvdisk_crc16_gen_factors (0x8408);                       
   1dc38:	e59f0208 	ldr	r0, [pc, #520]	; 1de48 <rtems_nvdisk_initialize+0x228><== NOT EXECUTED
   1dc3c:	ebffffdb 	bl	1dbb0 <rtems_nvdisk_crc16_gen_factors>         <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
   1dc40:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1dc44:	11a08006 	movne	r8, r6                                      <== NOT EXECUTED
   1dc48:	1a00007b 	bne	1de3c <rtems_nvdisk_initialize+0x21c>         <== NOT EXECUTED
      return sc;                                                      
                                                                      
  rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,            
   1dc4c:	e59f41f8 	ldr	r4, [pc, #504]	; 1de4c <rtems_nvdisk_initialize+0x22c><== NOT EXECUTED
   1dc50:	e3a01028 	mov	r1, #40	; 0x28                                <== NOT EXECUTED
   1dc54:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   1dc58:	ebffa525 	bl	70f4 <calloc>                                  <== NOT EXECUTED
   1dc5c:	e59f31ec 	ldr	r3, [pc, #492]	; 1de50 <rtems_nvdisk_initialize+0x230><== NOT EXECUTED
                          sizeof (rtems_nvdisk));                     
                                                                      
  if (!rtems_nvdisks)                                                 
   1dc60:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  sc = rtems_nvdisk_crc16_gen_factors (0x8408);                       
  if (sc != RTEMS_SUCCESSFUL)                                         
      return sc;                                                      
                                                                      
  rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,            
   1dc64:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
                          sizeof (rtems_nvdisk));                     
                                                                      
  if (!rtems_nvdisks)                                                 
   1dc68:	159f51e4 	ldrne	r5, [pc, #484]	; 1de54 <rtems_nvdisk_initialize+0x234><== NOT EXECUTED
   1dc6c:	11a07006 	movne	r7, r6                                      <== NOT EXECUTED
   1dc70:	1a000068 	bne	1de18 <rtems_nvdisk_initialize+0x1f8>         <== NOT EXECUTED
   1dc74:	ea00006f 	b	1de38 <rtems_nvdisk_initialize+0x218>           <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";              
   1dc78:	e59f11d8 	ldr	r1, [pc, #472]	; 1de58 <rtems_nvdisk_initialize+0x238><== NOT EXECUTED
   1dc7c:	e3a0200a 	mov	r2, #10                                       <== NOT EXECUTED
   1dc80:	e28d0024 	add	r0, sp, #36	; 0x24                            <== NOT EXECUTED
   1dc84:	eb00894d 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
                                                                      
    nvd = &rtems_nvdisks[minor];                                      
   1dc88:	e59f11c0 	ldr	r1, [pc, #448]	; 1de50 <rtems_nvdisk_initialize+0x230><== NOT EXECUTED
                                                                      
    name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;            
   1dc8c:	e5dd202d 	ldrb	r2, [sp, #45]	; 0x2d                         <== NOT EXECUTED
    char     name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";              
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
                                                                      
    nvd = &rtems_nvdisks[minor];                                      
   1dc90:	e5913004 	ldr	r3, [r1, #4]                                  <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
   1dc94:	e59dc018 	ldr	ip, [sp, #24]                                 <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
   1dc98:	e58d7034 	str	r7, [sp, #52]	; 0x34                          <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
   1dc9c:	e58dc030 	str	ip, [sp, #48]	; 0x30                          <== NOT EXECUTED
   1dca0:	e0834006 	add	r4, r3, r6                                    <== NOT EXECUTED
                                                                      
    name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;            
   1dca4:	e0872002 	add	r2, r7, r2                                    <== NOT EXECUTED
   1dca8:	e5cd202d 	strb	r2, [sp, #45]	; 0x2d                         <== NOT EXECUTED
  temp.__overlay.minor = _minor;                                      
  return temp.device;                                                 
   1dcac:	e28d2030 	add	r2, sp, #48	; 0x30                            <== NOT EXECUTED
   1dcb0:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
                                                                      
    nvd->major        = major;                                        
   1dcb4:	e783c006 	str	ip, [r3, r6]                                  <== NOT EXECUTED
    nvd->minor        = minor;                                        
   1dcb8:	e5847004 	str	r7, [r4, #4]                                  <== NOT EXECUTED
    nvd->flags        = c->flags;                                     
   1dcbc:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   1dcc0:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
    nvd->block_size   = c->block_size;                                
   1dcc4:	e515300c 	ldr	r3, [r5, #-12]                                <== NOT EXECUTED
   1dcc8:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
    nvd->info_level   = c->info_level;                                
   1dccc:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
   1dcd0:	e5843024 	str	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
   1dcd4:	e58d101c 	str	r1, [sp, #28]                                 <== NOT EXECUTED
   1dcd8:	e58d2020 	str	r2, [sp, #32]                                 <== NOT EXECUTED
                                                                      
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
   1dcdc:	e5150008 	ldr	r0, [r5, #-8]                                 <== NOT EXECUTED
   1dce0:	e3a01014 	mov	r1, #20                                       <== NOT EXECUTED
   1dce4:	ebffa502 	bl	70f4 <calloc>                                  <== NOT EXECUTED
    if (!nvd->devices)                                                
   1dce8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    nvd->minor        = minor;                                        
    nvd->flags        = c->flags;                                     
    nvd->block_size   = c->block_size;                                
    nvd->info_level   = c->info_level;                                
                                                                      
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
   1dcec:	e5840014 	str	r0, [r4, #20]                                 <== NOT EXECUTED
    if (!nvd->devices)                                                
   1dcf0:	0a000050 	beq	1de38 <rtems_nvdisk_initialize+0x218>         <== NOT EXECUTED
   1dcf4:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
   1dcf8:	e1a0a008 	mov	sl, r8                                        <== NOT EXECUTED
   1dcfc:	e1a09008 	mov	r9, r8                                        <== NOT EXECUTED
   1dd00:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   1dd04:	ea00001f 	b	1dd88 <rtems_nvdisk_initialize+0x168>           <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
                                                                      
    for (device = 0; device < c->device_count; device++)              
    {                                                                 
      rtems_nvdisk_device_ctl* dc = &nvd->devices[device];            
   1dd08:	e5946014 	ldr	r6, [r4, #20]                                 <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_pages_in_device (const rtems_nvdisk*             nvd,    
                              const rtems_nvdisk_device_desc* dd)     
{                                                                     
  return dd->size / nvd->block_size;                                  
   1dd0c:	e515b004 	ldr	fp, [r5, #-4]                                 <== NOT EXECUTED
                                                                      
    for (device = 0; device < c->device_count; device++)              
    {                                                                 
      rtems_nvdisk_device_ctl* dc = &nvd->devices[device];            
                                                                      
      dc->device     = device;                                        
   1dd10:	e7869008 	str	r9, [r6, r8]                                  <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_pages_in_device (const rtems_nvdisk*             nvd,    
                              const rtems_nvdisk_device_desc* dd)     
{                                                                     
  return dd->size / nvd->block_size;                                  
   1dd14:	e08bb209 	add	fp, fp, r9, lsl #4                            <== NOT EXECUTED
   1dd18:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
   1dd1c:	e59b0008 	ldr	r0, [fp, #8]                                  <== NOT EXECUTED
   1dd20:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
   1dd24:	eb00dc33 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
    if (!nvd->devices)                                                
      return RTEMS_NO_MEMORY;                                         
                                                                      
    for (device = 0; device < c->device_count; device++)              
    {                                                                 
      rtems_nvdisk_device_ctl* dc = &nvd->devices[device];            
   1dd28:	e0866008 	add	r6, r6, r8                                    <== NOT EXECUTED
                                                                      
      dc->device     = device;                                        
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
   1dd2c:	e5860004 	str	r0, [r6, #4]                                  <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_pages_in_device (const rtems_nvdisk*             nvd,    
                              const rtems_nvdisk_device_desc* dd)     
{                                                                     
  return dd->size / nvd->block_size;                                  
   1dd30:	e594c00c 	ldr	ip, [r4, #12]                                 <== NOT EXECUTED
   1dd34:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk*             nvd,    
                              const rtems_nvdisk_device_desc* dd)     
{                                                                     
  uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);            
  uint32_t bytes = pages * sizeof (uint16_t);                         
  return ((bytes - 1) / nvd->block_size) + 1;                         
   1dd38:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
   1dd3c:	e59b0008 	ldr	r0, [fp, #8]                                  <== NOT EXECUTED
   1dd40:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
   1dd44:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
   1dd48:	eb00dc2a 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   1dd4c:	e59dc014 	ldr	ip, [sp, #20]                                 <== NOT EXECUTED
   1dd50:	e1a00080 	lsl	r0, r0, #1                                    <== NOT EXECUTED
   1dd54:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
   1dd58:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
   1dd5c:	eb00dc25 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
      dc->device     = device;                                        
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
      dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
      dc->block_base = blocks;                                        
                                                                      
      blocks += dc->pages - dc->pages_desc;                           
   1dd60:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk*             nvd,    
                              const rtems_nvdisk_device_desc* dd)     
{                                                                     
  uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);            
  uint32_t bytes = pages * sizeof (uint16_t);                         
  return ((bytes - 1) / nvd->block_size) + 1;                         
   1dd64:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
      dc->device     = device;                                        
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
      dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
      dc->block_base = blocks;                                        
                                                                      
      blocks += dc->pages - dc->pages_desc;                           
   1dd68:	e0602002 	rsb	r2, r0, r2                                    <== NOT EXECUTED
                                                                      
      dc->descriptor = &c->devices[device];                           
   1dd6c:	e586b010 	str	fp, [r6, #16]                                 <== NOT EXECUTED
    {                                                                 
      rtems_nvdisk_device_ctl* dc = &nvd->devices[device];            
                                                                      
      dc->device     = device;                                        
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
      dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
   1dd70:	e5860008 	str	r0, [r6, #8]                                  <== NOT EXECUTED
                                                                      
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
    if (!nvd->devices)                                                
      return RTEMS_NO_MEMORY;                                         
                                                                      
    for (device = 0; device < c->device_count; device++)              
   1dd74:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
      rtems_nvdisk_device_ctl* dc = &nvd->devices[device];            
                                                                      
      dc->device     = device;                                        
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
      dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
      dc->block_base = blocks;                                        
   1dd78:	e586a00c 	str	sl, [r6, #12]                                 <== NOT EXECUTED
                                                                      
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
    if (!nvd->devices)                                                
      return RTEMS_NO_MEMORY;                                         
                                                                      
    for (device = 0; device < c->device_count; device++)              
   1dd7c:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
      dc->device     = device;                                        
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
      dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
      dc->block_base = blocks;                                        
                                                                      
      blocks += dc->pages - dc->pages_desc;                           
   1dd80:	e08aa002 	add	sl, sl, r2                                    <== NOT EXECUTED
                                                                      
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
    if (!nvd->devices)                                                
      return RTEMS_NO_MEMORY;                                         
                                                                      
    for (device = 0; device < c->device_count; device++)              
   1dd84:	e2888014 	add	r8, r8, #20                                   <== NOT EXECUTED
   1dd88:	e5152008 	ldr	r2, [r5, #-8]                                 <== NOT EXECUTED
   1dd8c:	e1590002 	cmp	r9, r2                                        <== NOT EXECUTED
   1dd90:	3affffdc 	bcc	1dd08 <rtems_nvdisk_initialize+0xe8>          <== NOT EXECUTED
      blocks += dc->pages - dc->pages_desc;                           
                                                                      
      dc->descriptor = &c->devices[device];                           
    }                                                                 
                                                                      
    nvd->block_count  = blocks;                                       
   1dd94:	e584a010 	str	sl, [r4, #16]                                 <== NOT EXECUTED
   1dd98:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
    nvd->device_count = c->device_count;                              
   1dd9c:	e5153008 	ldr	r3, [r5, #-8]                                 <== NOT EXECUTED
                                                                      
    sc = rtems_disk_create_phys(dev, c->block_size, blocks,           
   1dda0:	e59fc0b4 	ldr	ip, [pc, #180]	; 1de5c <rtems_nvdisk_initialize+0x23c><== NOT EXECUTED
                                                                      
      dc->descriptor = &c->devices[device];                           
    }                                                                 
                                                                      
    nvd->block_count  = blocks;                                       
    nvd->device_count = c->device_count;                              
   1dda4:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
                                                                      
    sc = rtems_disk_create_phys(dev, c->block_size, blocks,           
   1dda8:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1ddac:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1ddb0:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   1ddb4:	e28d101c 	add	r1, sp, #28                                   <== NOT EXECUTED
   1ddb8:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   1ddbc:	e28dc024 	add	ip, sp, #36	; 0x24                            <== NOT EXECUTED
   1ddc0:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   1ddc4:	e515200c 	ldr	r2, [r5, #-12]                                <== NOT EXECUTED
   1ddc8:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   1ddcc:	ebffa268 	bl	6774 <rtems_disk_create_phys>                  <== NOT EXECUTED
                                rtems_nvdisk_ioctl, NULL, name);      
    if (sc != RTEMS_SUCCESSFUL)                                       
   1ddd0:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
    {                                                                 
      rtems_nvdisk_error ("disk create phy failed");                  
   1ddd4:	159f0084 	ldrne	r0, [pc, #132]	; 1de60 <rtems_nvdisk_initialize+0x240><== NOT EXECUTED
   1ddd8:	1a00000b 	bne	1de0c <rtems_nvdisk_initialize+0x1ec>         <== NOT EXECUTED
      return sc;                                                      
    }                                                                 
                                                                      
    sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
   1dddc:	e2844020 	add	r4, r4, #32                                   <== NOT EXECUTED
   1dde0:	e59f007c 	ldr	r0, [pc, #124]	; 1de64 <rtems_nvdisk_initialize+0x244><== NOT EXECUTED
   1dde4:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1dde8:	e3a02054 	mov	r2, #84	; 0x54                                <== NOT EXECUTED
   1ddec:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   1ddf0:	e58d4000 	str	r4, [sp]                                      <== NOT EXECUTED
   1ddf4:	ebffb608 	bl	b61c <rtems_semaphore_create>                  <== NOT EXECUTED
                                 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
                                 RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
    if (sc != RTEMS_SUCCESSFUL)                                       
   1ddf8:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
    {                                                                 
      rtems_nvdisk_error ("disk create phy failed");                  
      return sc;                                                      
    }                                                                 
                                                                      
    sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
   1ddfc:	e2866028 	add	r6, r6, #40	; 0x28                            <== NOT EXECUTED
   1de00:	e2855014 	add	r5, r5, #20                                   <== NOT EXECUTED
                                 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
                                 RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
    if (sc != RTEMS_SUCCESSFUL)                                       
   1de04:	0a000002 	beq	1de14 <rtems_nvdisk_initialize+0x1f4>         <== NOT EXECUTED
    {                                                                 
      rtems_nvdisk_error ("disk lock create failed");                 
   1de08:	e59f0058 	ldr	r0, [pc, #88]	; 1de68 <rtems_nvdisk_initialize+0x248><== NOT EXECUTED
   1de0c:	ebfffdcb 	bl	1d540 <rtems_nvdisk_error>                     <== NOT EXECUTED
      return sc;                                                      
   1de10:	ea000009 	b	1de3c <rtems_nvdisk_initialize+0x21c>           <== NOT EXECUTED
                          sizeof (rtems_nvdisk));                     
                                                                      
  if (!rtems_nvdisks)                                                 
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
   1de14:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   1de18:	e59f102c 	ldr	r1, [pc, #44]	; 1de4c <rtems_nvdisk_initialize+0x22c><== NOT EXECUTED
   1de1c:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
   1de20:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
   1de24:	3affff93 	bcc	1dc78 <rtems_nvdisk_initialize+0x58>          <== NOT EXECUTED
      rtems_nvdisk_error ("disk lock create failed");                 
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_nvdisk_count = rtems_nvdisk_configuration_size;               
   1de28:	e59f2020 	ldr	r2, [pc, #32]	; 1de50 <rtems_nvdisk_initialize+0x230><== NOT EXECUTED
   1de2c:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
   1de30:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
   1de34:	ea000000 	b	1de3c <rtems_nvdisk_initialize+0x21c>           <== NOT EXECUTED
   1de38:	e3a0801a 	mov	r8, #26                                       <== NOT EXECUTED
}                                                                     
   1de3c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   1de40:	e28dd038 	add	sp, sp, #56	; 0x38                            <== NOT EXECUTED
   1de44:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0001d63c <rtems_nvdisk_ioctl>: * @param argp IOCTL argument. * @retval The IOCTL return value */ static int rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp) {
   1d63c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  dev_t                     dev = rtems_disk_get_device_identifier (dd);
  rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
  rtems_blkdev_request*     r = argp;                                 
  rtems_status_code         sc;                                       
                                                                      
  if (minor >= rtems_nvdisk_count)                                    
   1d640:	e59f6550 	ldr	r6, [pc, #1360]	; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
  dev_t device                                                        
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.device = device;                                               
   1d644:	e5903004 	ldr	r3, [r0, #4]                                  <== NOT EXECUTED
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)  
{                                                                     
   1d648:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  dev_t                     dev = rtems_disk_get_device_identifier (dd);
  rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
  rtems_blkdev_request*     r = argp;                                 
  rtems_status_code         sc;                                       
                                                                      
  if (minor >= rtems_nvdisk_count)                                    
   1d64c:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
   1d650:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
 * @param argp IOCTL argument.                                        
 * @retval The IOCTL return value                                     
 */                                                                   
static int                                                            
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)  
{                                                                     
   1d654:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
   1d658:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   1d65c:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  dev_t                     dev = rtems_disk_get_device_identifier (dd);
  rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
  rtems_blkdev_request*     r = argp;                                 
  rtems_status_code         sc;                                       
                                                                      
  if (minor >= rtems_nvdisk_count)                                    
   1d660:	2a000006 	bcs	1d680 <rtems_nvdisk_ioctl+0x44>               <== NOT EXECUTED
  {                                                                   
    errno = ENODEV;                                                   
    return -1;                                                        
  }                                                                   
                                                                      
  if (rtems_nvdisks[minor].device_count == 0)                         
   1d664:	e3a02028 	mov	r2, #40	; 0x28                                <== NOT EXECUTED
   1d668:	e0090392 	mul	r9, r2, r3                                    <== NOT EXECUTED
   1d66c:	e5963004 	ldr	r3, [r6, #4]                                  <== NOT EXECUTED
   1d670:	e0833009 	add	r3, r3, r9                                    <== NOT EXECUTED
   1d674:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
   1d678:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1d67c:	1a000004 	bne	1d694 <rtems_nvdisk_ioctl+0x58>               <== NOT EXECUTED
  {                                                                   
    errno = ENODEV;                                                   
   1d680:	eb007e1e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d684:	e3a03013 	mov	r3, #19                                       <== NOT EXECUTED
   1d688:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1d68c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
   1d690:	ea00013a 	b	1db80 <rtems_nvdisk_ioctl+0x544>                <== NOT EXECUTED
  }                                                                   
                                                                      
  errno = 0;                                                          
   1d694:	eb007e19 	bl	3cf00 <__errno>                                <== NOT EXECUTED
                                                                      
  sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
   1d698:	e5962004 	ldr	r2, [r6, #4]                                  <== NOT EXECUTED
  {                                                                   
    errno = ENODEV;                                                   
    return -1;                                                        
  }                                                                   
                                                                      
  errno = 0;                                                          
   1d69c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                                                                      
  sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
   1d6a0:	e0822009 	add	r2, r2, r9                                    <== NOT EXECUTED
  {                                                                   
    errno = ENODEV;                                                   
    return -1;                                                        
  }                                                                   
                                                                      
  errno = 0;                                                          
   1d6a4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
                                                                      
  sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
   1d6a8:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   1d6ac:	e5920020 	ldr	r0, [r2, #32]                                 <== NOT EXECUTED
   1d6b0:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
   1d6b4:	ebffb881 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
   1d6b8:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   1d6bc:	1a000128 	bne	1db64 <rtems_nvdisk_ioctl+0x528>              <== NOT EXECUTED
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
   1d6c0:	eb007e0e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    switch (req)                                                      
   1d6c4:	e59f34d0 	ldr	r3, [pc, #1232]	; 1db9c <rtems_nvdisk_ioctl+0x560><== NOT EXECUTED
   1d6c8:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
      case RTEMS_NVDISK_IOCTL_ERASE_DISK:                             
        errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);      
        break;                                                        
                                                                      
      case RTEMS_NVDISK_IOCTL_INFO_LEVEL:                             
        rtems_nvdisks[minor].info_level = (uintptr_t) argp;           
   1d6cc:	05963004 	ldreq	r3, [r6, #4]                                <== NOT EXECUTED
   1d6d0:	00833009 	addeq	r3, r3, r9                                  <== NOT EXECUTED
  sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
  if (sc != RTEMS_SUCCESSFUL)                                         
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
   1d6d4:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
      case RTEMS_NVDISK_IOCTL_ERASE_DISK:                             
        errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);      
        break;                                                        
                                                                      
      case RTEMS_NVDISK_IOCTL_INFO_LEVEL:                             
        rtems_nvdisks[minor].info_level = (uintptr_t) argp;           
   1d6d8:	05834024 	streq	r4, [r3, #36]	; 0x24                        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
   1d6dc:	0a000119 	beq	1db48 <rtems_nvdisk_ioctl+0x50c>              <== NOT EXECUTED
   1d6e0:	e59f34b8 	ldr	r3, [pc, #1208]	; 1dba0 <rtems_nvdisk_ioctl+0x564><== NOT EXECUTED
   1d6e4:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   1d6e8:	0a000003 	beq	1d6fc <rtems_nvdisk_ioctl+0xc0>               <== NOT EXECUTED
   1d6ec:	e59f34b0 	ldr	r3, [pc, #1200]	; 1dba4 <rtems_nvdisk_ioctl+0x568><== NOT EXECUTED
   1d6f0:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   1d6f4:	1a00010f 	bne	1db38 <rtems_nvdisk_ioctl+0x4fc>              <== NOT EXECUTED
   1d6f8:	ea0000e3 	b	1da8c <rtems_nvdisk_ioctl+0x450>                <== NOT EXECUTED
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        switch (r->req)                                               
   1d6fc:	e5947000 	ldr	r7, [r4]                                      <== NOT EXECUTED
   1d700:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   1d704:	0a000002 	beq	1d714 <rtems_nvdisk_ioctl+0xd8>               <== NOT EXECUTED
   1d708:	e3570001 	cmp	r7, #1                                        <== NOT EXECUTED
   1d70c:	1a0000da 	bne	1da7c <rtems_nvdisk_ioctl+0x440>              <== NOT EXECUTED
   1d710:	ea000070 	b	1d8d8 <rtems_nvdisk_ioctl+0x29c>                <== NOT EXECUTED
        {                                                             
          case RTEMS_BLKDEV_REQ_READ:                                 
            errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);     
   1d714:	eb007df9 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d718:	e5965004 	ldr	r5, [r6, #4]                                  <== NOT EXECUTED
   1d71c:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
 * @retval int The ioctl return value.                                
 */                                                                   
static int                                                            
rtems_nvdisk_read (rtems_nvdisk* nvd, rtems_blkdev_request* req)      
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
   1d720:	e58d700c 	str	r7, [sp, #12]                                 <== NOT EXECUTED
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        switch (r->req)                                               
        {                                                             
          case RTEMS_BLKDEV_REQ_READ:                                 
            errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);     
   1d724:	e0855009 	add	r5, r5, r9                                    <== NOT EXECUTED
 * @retval int The ioctl return value.                                
 */                                                                   
static int                                                            
rtems_nvdisk_read (rtems_nvdisk* nvd, rtems_blkdev_request* req)      
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
   1d728:	e2846018 	add	r6, r4, #24                                   <== NOT EXECUTED
   1d72c:	ea00005c 	b	1d8a4 <rtems_nvdisk_ioctl+0x268>                <== NOT EXECUTED
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
  {                                                                   
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
   1d730:	e5960004 	ldr	r0, [r6, #4]                                  <== NOT EXECUTED
   1d734:	e595100c 	ldr	r1, [r5, #12]                                 <== NOT EXECUTED
   1d738:	eb00ddae 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
    data = sg->buffer;                                                
   1d73c:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
  {                                                                   
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
   1d740:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
    data = sg->buffer;                                                
   1d744:	e5967008 	ldr	r7, [r6, #8]                                  <== NOT EXECUTED
   1d748:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
   1d74c:	ea00004c 	b	1d884 <rtems_nvdisk_ioctl+0x248>                <== NOT EXECUTED
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
    {                                                                 
      ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);       
   1d750:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
   1d754:	e08a3003 	add	r3, sl, r3                                    <== NOT EXECUTED
  uint32_t                 page;                                      
  uint16_t                 crc;                                       
  uint16_t                 cs;                                        
  int                      ret;                                       
                                                                      
  dc = rtems_nvdisk_get_device (nvd, block);                          
   1d758:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d75c:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
    data = sg->buffer;                                                
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
    {                                                                 
      ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);       
   1d760:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
  uint32_t                 page;                                      
  uint16_t                 crc;                                       
  uint16_t                 cs;                                        
  int                      ret;                                       
                                                                      
  dc = rtems_nvdisk_get_device (nvd, block);                          
   1d764:	ebffff91 	bl	1d5b0 <rtems_nvdisk_get_device>                <== NOT EXECUTED
                                                                      
  if (!dc)                                                            
   1d768:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1d76c:	01a04008 	moveq	r4, r8                                      <== NOT EXECUTED
   1d770:	0a00003d 	beq	1d86c <rtems_nvdisk_ioctl+0x230>              <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d774:	e5952014 	ldr	r2, [r5, #20]                                 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_info (nvd, " read-block:%d=>%02d-%03d, cs:%04x",       
                     block, dc->device, page, crc);                   
#endif                                                                
                                                                      
  ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);     
   1d778:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d77c:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   1d780:	e0232390 	mla	r3, r0, r3, r2                                <== NOT EXECUTED
   1d784:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,                   
                       uint32_t                 block)                
{                                                                     
  return block - dc->block_base;                                      
   1d788:	e594b00c 	ldr	fp, [r4, #12]                                 <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-read: %02d-%08x: s=%d",            
                      device, offset, size);                          
#endif                                                                
  return ops->read (device, dd->flags, dd->base, offset, buffer, size);
   1d78c:	e28d101a 	add	r1, sp, #26                                   <== NOT EXECUTED
   1d790:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,                   
                       uint32_t                 block)                
{                                                                     
  return block - dc->block_base;                                      
   1d794:	e59de008 	ldr	lr, [sp, #8]                                  <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-read: %02d-%08x: s=%d",            
                      device, offset, size);                          
#endif                                                                
  return ops->read (device, dd->flags, dd->base, offset, buffer, size);
   1d798:	e593c00c 	ldr	ip, [r3, #12]                                 <== NOT EXECUTED
   1d79c:	e88d0006 	stm	sp, {r1, r2}                                  <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,                   
                       uint32_t                 block)                
{                                                                     
  return block - dc->block_base;                                      
   1d7a0:	e06bb00e 	rsb	fp, fp, lr                                    <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-read: %02d-%08x: s=%d",            
                      device, offset, size);                          
#endif                                                                
  return ops->read (device, dd->flags, dd->base, offset, buffer, size);
   1d7a4:	e8930006 	ldm	r3, {r1, r2}                                  <== NOT EXECUTED
   1d7a8:	e1a0308b 	lsl	r3, fp, #1                                    <== NOT EXECUTED
   1d7ac:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1d7b0:	e59cf000 	ldr	pc, [ip]                                      <== NOT EXECUTED
                     block, dc->device, page, crc);                   
#endif                                                                
                                                                      
  ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);     
                                                                      
  if (ret)                                                            
   1d7b4:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   1d7b8:	1a00002d 	bne	1d874 <rtems_nvdisk_ioctl+0x238>              <== NOT EXECUTED
    return ret;                                                       
                                                                      
  if (crc == 0xffff)                                                  
   1d7bc:	e59f23e4 	ldr	r2, [pc, #996]	; 1dba8 <rtems_nvdisk_ioctl+0x56c><== NOT EXECUTED
   1d7c0:	e1dd31ba 	ldrh	r3, [sp, #26]                                <== NOT EXECUTED
   1d7c4:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   1d7c8:	e595200c 	ldr	r2, [r5, #12]                                 <== NOT EXECUTED
   1d7cc:	1a000002 	bne	1d7dc <rtems_nvdisk_ioctl+0x1a0>              <== NOT EXECUTED
  {                                                                   
#if RTEMS_NVDISK_TRACE                                                
    rtems_nvdisk_warning (nvd, "read-block: crc not set: %d", block); 
#endif                                                                
    memset (buffer, 0, nvd->block_size);                              
   1d7d0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1d7d4:	eb008b00 	bl	403dc <memset>                                 <== NOT EXECUTED
   1d7d8:	ea0000ea 	b	1db88 <rtems_nvdisk_ioctl+0x54c>                <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d7dc:	e5951014 	ldr	r1, [r5, #20]                                 <== NOT EXECUTED
#endif                                                                
    memset (buffer, 0, nvd->block_size);                              
    return 0;                                                         
  }                                                                   
                                                                      
  ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
   1d7e0:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d7e4:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   1d7e8:	e0231390 	mla	r3, r0, r3, r1                                <== NOT EXECUTED
   1d7ec:	e5931010 	ldr	r1, [r3, #16]                                 <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-read: %02d-%08x: s=%d",            
                      device, offset, size);                          
#endif                                                                
  return ops->read (device, dd->flags, dd->base, offset, buffer, size);
   1d7f0:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   1d7f4:	e591c00c 	ldr	ip, [r1, #12]                                 <== NOT EXECUTED
   1d7f8:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
   1d7fc:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   1d800:	e08b3003 	add	r3, fp, r3                                    <== NOT EXECUTED
   1d804:	e0030392 	mul	r3, r2, r3                                    <== NOT EXECUTED
   1d808:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
   1d80c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1d810:	e59cf000 	ldr	pc, [ip]                                      <== NOT EXECUTED
    return 0;                                                         
  }                                                                   
                                                                      
  ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
                                                                      
  if (ret)                                                            
   1d814:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   1d818:	1a000015 	bne	1d874 <rtems_nvdisk_ioctl+0x238>              <== NOT EXECUTED
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_nvdisk_calc_crc16 (cs, *buffer);                       
   1d81c:	e59fe374 	ldr	lr, [pc, #884]	; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
  ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
                                                                      
  if (ret)                                                            
    return ret;                                                       
                                                                      
  cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);          
   1d820:	e595000c 	ldr	r0, [r5, #12]                                 <== NOT EXECUTED
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_nvdisk_calc_crc16 (cs, *buffer);                       
   1d824:	e59e3008 	ldr	r3, [lr, #8]                                  <== NOT EXECUTED
   1d828:	e59f2378 	ldr	r2, [pc, #888]	; 1dba8 <rtems_nvdisk_ioctl+0x56c><== NOT EXECUTED
   1d82c:	ea000005 	b	1d848 <rtems_nvdisk_ioctl+0x20c>                <== NOT EXECUTED
   1d830:	e7d7c001 	ldrb	ip, [r7, r1]                                 <== NOT EXECUTED
   1d834:	e022200c 	eor	r2, r2, ip                                    <== NOT EXECUTED
   1d838:	e20220ff 	and	r2, r2, #255	; 0xff                           <== NOT EXECUTED
   1d83c:	e1a02082 	lsl	r2, r2, #1                                    <== NOT EXECUTED
   1d840:	e19320b2 	ldrh	r2, [r3, r2]                                 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
   1d844:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
   1d848:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
   1d84c:	3afffff7 	bcc	1d830 <rtems_nvdisk_ioctl+0x1f4>              <== NOT EXECUTED
  if (ret)                                                            
    return ret;                                                       
                                                                      
  cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);          
                                                                      
  if (cs != crc)                                                      
   1d850:	e1dd31ba 	ldrh	r3, [sp, #26]                                <== NOT EXECUTED
   1d854:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   1d858:	0a0000ca 	beq	1db88 <rtems_nvdisk_ioctl+0x54c>              <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
   1d85c:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
   1d860:	e59f0344 	ldr	r0, [pc, #836]	; 1dbac <rtems_nvdisk_ioctl+0x570><== NOT EXECUTED
   1d864:	e1a04008 	mov	r4, r8                                        <== NOT EXECUTED
   1d868:	ebffff34 	bl	1d540 <rtems_nvdisk_error>                     <== NOT EXECUTED
   1d86c:	e3a0b005 	mov	fp, #5                                        <== NOT EXECUTED
   1d870:	ea000001 	b	1d87c <rtems_nvdisk_ioctl+0x240>                <== NOT EXECUTED
   1d874:	e1a0b001 	mov	fp, r1                                        <== NOT EXECUTED
   1d878:	e1a04008 	mov	r4, r8                                        <== NOT EXECUTED
   1d87c:	e3a0101b 	mov	r1, #27                                       <== NOT EXECUTED
   1d880:	ea00000d 	b	1d8bc <rtems_nvdisk_ioctl+0x280>                <== NOT EXECUTED
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
    data = sg->buffer;                                                
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
   1d884:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   1d888:	e15a0001 	cmp	sl, r1                                        <== NOT EXECUTED
   1d88c:	3affffaf 	bcc	1d750 <rtems_nvdisk_ioctl+0x114>              <== NOT EXECUTED
                                                                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);            
#endif                                                                
                                                                      
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
   1d890:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1d894:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   1d898:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
   1d89c:	e1a04008 	mov	r4, r8                                        <== NOT EXECUTED
   1d8a0:	e2866010 	add	r6, r6, #16                                   <== NOT EXECUTED
   1d8a4:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   1d8a8:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   1d8ac:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   1d8b0:	3affff9e 	bcc	1d730 <rtems_nvdisk_ioctl+0xf4>               <== NOT EXECUTED
   1d8b4:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   1d8b8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;              
   1d8bc:	e584100c 	str	r1, [r4, #12]                                 <== NOT EXECUTED
  req->req_done (req->done_arg, req->status);                         
   1d8c0:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
   1d8c4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1d8c8:	e594f004 	ldr	pc, [r4, #4]                                  <== NOT EXECUTED
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        switch (r->req)                                               
        {                                                             
          case RTEMS_BLKDEV_REQ_READ:                                 
            errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);     
   1d8cc:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
   1d8d0:	e583b000 	str	fp, [r3]                                      <== NOT EXECUTED
            break;                                                    
   1d8d4:	ea00009b 	b	1db48 <rtems_nvdisk_ioctl+0x50c>                <== NOT EXECUTED
                                                                      
          case RTEMS_BLKDEV_REQ_WRITE:                                
            errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);    
   1d8d8:	eb007d88 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1d8dc:	e5965004 	ldr	r5, [r6, #4]                                  <== NOT EXECUTED
   1d8e0:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
 * @retval int The ioctl return value.                                
 */                                                                   
static int                                                            
rtems_nvdisk_write (rtems_nvdisk* nvd, rtems_blkdev_request* req)     
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
   1d8e4:	e58d8008 	str	r8, [sp, #8]                                  <== NOT EXECUTED
          case RTEMS_BLKDEV_REQ_READ:                                 
            errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);     
            break;                                                    
                                                                      
          case RTEMS_BLKDEV_REQ_WRITE:                                
            errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);    
   1d8e8:	e0855009 	add	r5, r5, r9                                    <== NOT EXECUTED
 * @retval int The ioctl return value.                                
 */                                                                   
static int                                                            
rtems_nvdisk_write (rtems_nvdisk* nvd, rtems_blkdev_request* req)     
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
   1d8ec:	e2846018 	add	r6, r4, #24                                   <== NOT EXECUTED
   1d8f0:	e1a0b009 	mov	fp, r9                                        <== NOT EXECUTED
   1d8f4:	ea000052 	b	1da44 <rtems_nvdisk_ioctl+0x408>                <== NOT EXECUTED
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
  {                                                                   
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
   1d8f8:	e5960004 	ldr	r0, [r6, #4]                                  <== NOT EXECUTED
   1d8fc:	e595100c 	ldr	r1, [r5, #12]                                 <== NOT EXECUTED
   1d900:	eb00dd3c 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
    data = sg->buffer;                                                
   1d904:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
  {                                                                   
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
   1d908:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
    data = sg->buffer;                                                
   1d90c:	e5968008 	ldr	r8, [r6, #8]                                  <== NOT EXECUTED
   1d910:	e1a09004 	mov	r9, r4                                        <== NOT EXECUTED
   1d914:	ea00003d 	b	1da10 <rtems_nvdisk_ioctl+0x3d4>                <== NOT EXECUTED
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
    {                                                                 
      ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);      
   1d918:	e5967000 	ldr	r7, [r6]                                      <== NOT EXECUTED
   1d91c:	e08a7007 	add	r7, sl, r7                                    <== NOT EXECUTED
  rtems_nvdisk_device_ctl* dc;                                        
  uint32_t                 page;                                      
  uint16_t                 cs;                                        
  int                      ret;                                       
                                                                      
  dc = rtems_nvdisk_get_device (nvd, block);                          
   1d920:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1d924:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1d928:	ebffff20 	bl	1d5b0 <rtems_nvdisk_get_device>                <== NOT EXECUTED
                                                                      
  if (!dc)                                                            
   1d92c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1d930:	0a00003f 	beq	1da34 <rtems_nvdisk_ioctl+0x3f8>              <== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,                   
                       uint32_t                 block)                
{                                                                     
  return block - dc->block_base;                                      
   1d934:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_nvdisk_calc_crc16 (cs, *buffer);                       
   1d938:	e59fe258 	ldr	lr, [pc, #600]	; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
 */                                                                   
static uint32_t                                                       
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,                   
                       uint32_t                 block)                
{                                                                     
  return block - dc->block_base;                                      
   1d93c:	e0633007 	rsb	r3, r3, r7                                    <== NOT EXECUTED
   1d940:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
  if (!dc)                                                            
    return EIO;                                                       
                                                                      
  page = rtems_nvdisk_get_page (dc, block);                           
                                                                      
  cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);          
   1d944:	e595200c 	ldr	r2, [r5, #12]                                 <== NOT EXECUTED
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_nvdisk_calc_crc16 (cs, *buffer);                       
   1d948:	e59e1008 	ldr	r1, [lr, #8]                                  <== NOT EXECUTED
   1d94c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   1d950:	e59f7250 	ldr	r7, [pc, #592]	; 1dba8 <rtems_nvdisk_ioctl+0x56c><== NOT EXECUTED
   1d954:	ea000005 	b	1d970 <rtems_nvdisk_ioctl+0x334>                <== NOT EXECUTED
   1d958:	e7d80003 	ldrb	r0, [r8, r3]                                 <== NOT EXECUTED
   1d95c:	e0270000 	eor	r0, r7, r0                                    <== NOT EXECUTED
   1d960:	e20000ff 	and	r0, r0, #255	; 0xff                           <== NOT EXECUTED
   1d964:	e1a00080 	lsl	r0, r0, #1                                    <== NOT EXECUTED
   1d968:	e19170b0 	ldrh	r7, [r1, r0]                                 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
   1d96c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   1d970:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   1d974:	3afffff7 	bcc	1d958 <rtems_nvdisk_ioctl+0x31c>              <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d978:	e5951014 	ldr	r1, [r5, #20]                                 <== NOT EXECUTED
                                                                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif                                                                
                                                                      
  ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
   1d97c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d980:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   1d984:	e0231390 	mla	r3, r0, r3, r1                                <== NOT EXECUTED
   1d988:	e5931010 	ldr	r1, [r3, #16]                                 <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1d98c:	e59de00c 	ldr	lr, [sp, #12]                                 <== NOT EXECUTED
   1d990:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   1d994:	e591c00c 	ldr	ip, [r1, #12]                                 <== NOT EXECUTED
   1d998:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
   1d99c:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   1d9a0:	e08e3003 	add	r3, lr, r3                                    <== NOT EXECUTED
   1d9a4:	e0030392 	mul	r3, r2, r3                                    <== NOT EXECUTED
   1d9a8:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
   1d9ac:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1d9b0:	e59cf004 	ldr	pc, [ip, #4]                                  <== NOT EXECUTED
  rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif                                                                
                                                                      
  ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
                                                                      
  if (ret)                                                            
   1d9b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1d9b8:	1a00001d 	bne	1da34 <rtems_nvdisk_ioctl+0x3f8>              <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d9bc:	e5952014 	ldr	r2, [r5, #20]                                 <== NOT EXECUTED
  ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
                                                                      
  if (ret)                                                            
    return ret;                                                       
                                                                      
  return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);     
   1d9c0:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1d9c4:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   1d9c8:	e0232390 	mla	r3, r0, r3, r2                                <== NOT EXECUTED
   1d9cc:	e5931010 	ldr	r1, [r3, #16]                                 <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1d9d0:	e28d201a 	add	r2, sp, #26                                   <== NOT EXECUTED
   1d9d4:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   1d9d8:	e591c00c 	ldr	ip, [r1, #12]                                 <== NOT EXECUTED
   1d9dc:	e59de00c 	ldr	lr, [sp, #12]                                 <== NOT EXECUTED
   1d9e0:	e88d000c 	stm	sp, {r2, r3}                                  <== NOT EXECUTED
  ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
                                                                      
  if (ret)                                                            
    return ret;                                                       
                                                                      
  return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);     
   1d9e4:	e1cd71ba 	strh	r7, [sp, #26]                                <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1d9e8:	e5912004 	ldr	r2, [r1, #4]                                  <== NOT EXECUTED
   1d9ec:	e1a0308e 	lsl	r3, lr, #1                                    <== NOT EXECUTED
   1d9f0:	e5911000 	ldr	r1, [r1]                                      <== NOT EXECUTED
   1d9f4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1d9f8:	e59cf004 	ldr	pc, [ip, #4]                                  <== NOT EXECUTED
    nvb = sg->length / nvd->block_size;                               
    data = sg->buffer;                                                
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
    {                                                                 
      ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);      
      if (ret)                                                        
   1d9fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1da00:	1a00000b 	bne	1da34 <rtems_nvdisk_ioctl+0x3f8>              <== NOT EXECUTED
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
    data = sg->buffer;                                                
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
   1da04:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
   1da08:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
   1da0c:	e0888003 	add	r8, r8, r3                                    <== NOT EXECUTED
   1da10:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   1da14:	e15a0001 	cmp	sl, r1                                        <== NOT EXECUTED
   1da18:	3affffbe 	bcc	1d918 <rtems_nvdisk_ioctl+0x2dc>              <== NOT EXECUTED
                                                                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);           
#endif                                                                
                                                                      
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
   1da1c:	e59de008 	ldr	lr, [sp, #8]                                  <== NOT EXECUTED
   1da20:	e28ee001 	add	lr, lr, #1                                    <== NOT EXECUTED
   1da24:	e1a04009 	mov	r4, r9                                        <== NOT EXECUTED
   1da28:	e58de008 	str	lr, [sp, #8]                                  <== NOT EXECUTED
   1da2c:	e2866010 	add	r6, r6, #16                                   <== NOT EXECUTED
   1da30:	ea000003 	b	1da44 <rtems_nvdisk_ioctl+0x408>                <== NOT EXECUTED
   1da34:	e1a04009 	mov	r4, r9                                        <== NOT EXECUTED
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
    data = sg->buffer;                                                
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
   1da38:	e3a0101b 	mov	r1, #27                                       <== NOT EXECUTED
   1da3c:	e1a0900b 	mov	r9, fp                                        <== NOT EXECUTED
   1da40:	ea000005 	b	1da5c <rtems_nvdisk_ioctl+0x420>                <== NOT EXECUTED
                                                                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);           
#endif                                                                
                                                                      
  for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)    
   1da44:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   1da48:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   1da4c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   1da50:	3affffa8 	bcc	1d8f8 <rtems_nvdisk_ioctl+0x2bc>              <== NOT EXECUTED
   1da54:	e1a0900b 	mov	r9, fp                                        <== NOT EXECUTED
   1da58:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;              
   1da5c:	e584100c 	str	r1, [r4, #12]                                 <== NOT EXECUTED
  req->req_done (req->done_arg, req->status);                         
   1da60:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
   1da64:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1da68:	e594f004 	ldr	pc, [r4, #4]                                  <== NOT EXECUTED
          case RTEMS_BLKDEV_REQ_READ:                                 
            errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);     
            break;                                                    
                                                                      
          case RTEMS_BLKDEV_REQ_WRITE:                                
            errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);    
   1da6c:	e59de014 	ldr	lr, [sp, #20]                                 <== NOT EXECUTED
   1da70:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   1da74:	e58e3000 	str	r3, [lr]                                      <== NOT EXECUTED
            break;                                                    
   1da78:	ea000032 	b	1db48 <rtems_nvdisk_ioctl+0x50c>                <== NOT EXECUTED
                                                                      
          default:                                                    
            errno = EINVAL;                                           
   1da7c:	eb007d1f 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1da80:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1da84:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1da88:	ea00002e 	b	1db48 <rtems_nvdisk_ioctl+0x50c>                <== NOT EXECUTED
            break;                                                    
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_NVDISK_IOCTL_ERASE_DISK:                             
        errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);      
   1da8c:	eb007d1b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1da90:	e5966004 	ldr	r6, [r6, #4]                                  <== NOT EXECUTED
   1da94:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
   1da98:	e1a04008 	mov	r4, r8                                        <== NOT EXECUTED
   1da9c:	e0866009 	add	r6, r6, r9                                    <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1daa0:	e3a0a014 	mov	sl, #20                                       <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1daa4:	e28db01a 	add	fp, sp, #26                                   <== NOT EXECUTED
   1daa8:	ea00001b 	b	1db1c <rtems_nvdisk_ioctl+0x4e0>                <== NOT EXECUTED
  rtems_nvdisk_info (nvd, "erase-disk");                              
#endif                                                                
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
   1daac:	e5967014 	ldr	r7, [r6, #20]                                 <== NOT EXECUTED
   1dab0:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   1dab4:	e0877004 	add	r7, r7, r4                                    <== NOT EXECUTED
   1dab8:	ea000010 	b	1db00 <rtems_nvdisk_ioctl+0x4c4>                <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1dabc:	e5961014 	ldr	r1, [r6, #20]                                 <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
    uint32_t                 page;                                    
    for (page = 0; page < (dc->pages - dc->pages_desc); page++)       
    {                                                                 
      int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
   1dac0:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
 * Get the descriptor for a device.                                   
 */                                                                   
static const rtems_nvdisk_device_desc*                                
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{                                                                     
  return nvd->devices[device].descriptor;                             
   1dac4:	e022109a 	mla	r2, sl, r0, r1                                <== NOT EXECUTED
   1dac8:	e5921010 	ldr	r1, [r2, #16]                                 <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1dacc:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
   1dad0:	e591c00c 	ldr	ip, [r1, #12]                                 <== NOT EXECUTED
   1dad4:	e58db000 	str	fp, [sp]                                      <== NOT EXECUTED
   1dad8:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
    uint32_t                 page;                                    
    for (page = 0; page < (dc->pages - dc->pages_desc); page++)       
    {                                                                 
      int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
   1dadc:	e3e0e000 	mvn	lr, #0                                        <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1dae0:	e5912004 	ldr	r2, [r1, #4]                                  <== NOT EXECUTED
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
    uint32_t                 page;                                    
    for (page = 0; page < (dc->pages - dc->pages_desc); page++)       
    {                                                                 
      int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
   1dae4:	e1cde1ba 	strh	lr, [sp, #26]                                <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1dae8:	e5911000 	ldr	r1, [r1]                                      <== NOT EXECUTED
   1daec:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1daf0:	e59cf004 	ldr	pc, [ip, #4]                                  <== NOT EXECUTED
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
    uint32_t                 page;                                    
    for (page = 0; page < (dc->pages - dc->pages_desc); page++)       
    {                                                                 
      int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
      if (ret)                                                        
   1daf4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1daf8:	1a00000b 	bne	1db2c <rtems_nvdisk_ioctl+0x4f0>              <== NOT EXECUTED
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
    uint32_t                 page;                                    
    for (page = 0; page < (dc->pages - dc->pages_desc); page++)       
   1dafc:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
   1db00:	e9970006 	ldmib	r7, {r1, r2}                                <== NOT EXECUTED
   1db04:	e0412002 	sub	r2, r1, r2                                    <== NOT EXECUTED
   1db08:	e1550002 	cmp	r5, r2                                        <== NOT EXECUTED
  ops = nvd->devices[device].descriptor->nv_ops;                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_printf (nvd, "  dev-write: %02d-%08x: s=%d",           
                      device, offset, size);                          
#endif                                                                
  return ops->write (device, dd->flags, dd->base, offset, buffer, size);
   1db0c:	e1a03085 	lsl	r3, r5, #1                                    <== NOT EXECUTED
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
  {                                                                   
    rtems_nvdisk_device_ctl* dc = &nvd->devices[device];              
    uint32_t                 page;                                    
    for (page = 0; page < (dc->pages - dc->pages_desc); page++)       
   1db10:	3affffe9 	bcc	1dabc <rtems_nvdisk_ioctl+0x480>              <== NOT EXECUTED
                                                                      
#if RTEMS_NVDISK_TRACE                                                
  rtems_nvdisk_info (nvd, "erase-disk");                              
#endif                                                                
                                                                      
  for (device = 0; device < nvd->device_count; device++)              
   1db14:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   1db18:	e2844014 	add	r4, r4, #20                                   <== NOT EXECUTED
   1db1c:	e5963018 	ldr	r3, [r6, #24]                                 <== NOT EXECUTED
   1db20:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
   1db24:	3affffe0 	bcc	1daac <rtems_nvdisk_ioctl+0x470>              <== NOT EXECUTED
   1db28:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
            break;                                                    
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_NVDISK_IOCTL_ERASE_DISK:                             
        errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);      
   1db2c:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   1db30:	e5820000 	str	r0, [r2]                                      <== NOT EXECUTED
        break;                                                        
   1db34:	ea000003 	b	1db48 <rtems_nvdisk_ioctl+0x50c>                <== NOT EXECUTED
      case RTEMS_NVDISK_IOCTL_INFO_LEVEL:                             
        rtems_nvdisks[minor].info_level = (uintptr_t) argp;           
        break;                                                        
                                                                      
      default:                                                        
        rtems_blkdev_ioctl (dd, req, argp);                           
   1db38:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1db3c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1db40:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   1db44:	ebff9f1d 	bl	57c0 <rtems_blkdev_ioctl>                      <== NOT EXECUTED
        break;                                                        
    }                                                                 
                                                                      
    sc = rtems_semaphore_release (rtems_nvdisks[minor].lock);         
   1db48:	e59f3048 	ldr	r3, [pc, #72]	; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
   1db4c:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
   1db50:	e0839009 	add	r9, r3, r9                                    <== NOT EXECUTED
   1db54:	e5990020 	ldr	r0, [r9, #32]                                 <== NOT EXECUTED
   1db58:	ebffb79e 	bl	b9d8 <rtems_semaphore_release>                 <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
   1db5c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1db60:	0a000002 	beq	1db70 <rtems_nvdisk_ioctl+0x534>              <== NOT EXECUTED
      errno = EIO;                                                    
   1db64:	eb007ce5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1db68:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   1db6c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  return errno == 0 ? 0 : -1;                                         
   1db70:	eb007ce2 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1db74:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   1db78:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1db7c:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
}                                                                     
   1db80:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
   1db84:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    uint8_t* data;                                                    
    uint32_t nvb;                                                     
    uint32_t b;                                                       
    nvb = sg->length / nvd->block_size;                               
    data = sg->buffer;                                                
    for (b = 0; b < nvb; b++, data += nvd->block_size)                
   1db88:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
   1db8c:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
   1db90:	e0877003 	add	r7, r7, r3                                    <== NOT EXECUTED
   1db94:	eaffff3a 	b	1d884 <rtems_nvdisk_ioctl+0x248>                <== NOT EXECUTED
                                                                      

0001dea4 <rtems_nvdisk_sram_read>: uint32_t flags __attribute__((unused)), void* base, uint32_t offset, void* buffer, size_t size) {
   1dea4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  memcpy (buffer, (base + offset), size);                             
   1dea8:	e0821003 	add	r1, r2, r3                                    <== NOT EXECUTED
   1deac:	e99d0005 	ldmib	sp, {r0, r2}                                <== NOT EXECUTED
   1deb0:	eb0088c2 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   1deb4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   1deb8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

0001de6c <rtems_nvdisk_sram_verify>: uint32_t flags __attribute__((unused)), void* base, uint32_t offset, const void* buffer, size_t size) {
   1de6c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  return memcmp ((base + offset), buffer, size) == 0 ? 0 : EIO;       
   1de70:	e0820003 	add	r0, r2, r3                                    <== NOT EXECUTED
   1de74:	e99d0006 	ldmib	sp, {r1, r2}                                <== NOT EXECUTED
   1de78:	eb0088a6 	bl	40118 <memcmp>                                 <== NOT EXECUTED
}                                                                     
   1de7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1de80:	13a00005 	movne	r0, #5                                      <== NOT EXECUTED
   1de84:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   1de88:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

0001de8c <rtems_nvdisk_sram_write>: uint32_t flags __attribute__((unused)), void* base, uint32_t offset, const void* buffer, size_t size) {
   1de8c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  memcpy ((base + offset), buffer, size);                             
   1de90:	e0820003 	add	r0, r2, r3                                    <== NOT EXECUTED
   1de94:	e99d0006 	ldmib	sp, {r1, r2}                                <== NOT EXECUTED
   1de98:	eb0088c8 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   1de9c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   1dea0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00006654 <rtems_panic>: void rtems_panic( const char *printf_format, ... ) {
    6654:	e92d000f 	push	{r0, r1, r2, r3}                             <== NOT EXECUTED
    6658:	e92d4001 	push	{r0, lr}                                     <== NOT EXECUTED
    va_list arglist;                                                  
                                                                      
    va_start(arglist, printf_format);                                 
    665c:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
    (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);   
    6660:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    6664:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
    6668:	e3a00202 	mov	r0, #536870912	; 0x20000000                   <== NOT EXECUTED
    ...                                                               
  )                                                                   
{                                                                     
    va_list arglist;                                                  
                                                                      
    va_start(arglist, printf_format);                                 
    666c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);   
    6670:	ebffff8e 	bl	64b0 <rtems_verror>                            <== NOT EXECUTED
    va_end(arglist);                                                  
}                                                                     
    6674:	e8bd4008 	pop	{r3, lr}                                      <== NOT EXECUTED
    6678:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
    667c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

000087c4 <rtems_pipe_initialize>: /* * Initialization of FIFO/pipe module. */ void rtems_pipe_initialize (void) { if (!rtems_pipe_configured)
    87c4:	e59f3048 	ldr	r3, [pc, #72]	; 8814 <rtems_pipe_initialize+0x50>
    87c8:	e5d33000 	ldrb	r3, [r3]                                     
    87cc:	e3530000 	cmp	r3, #0                                        
                                                                      
/*                                                                    
 * Initialization of FIFO/pipe module.                                
 */                                                                   
void rtems_pipe_initialize (void)                                     
{                                                                     
    87d0:	e92d4001 	push	{r0, lr}                                     
  if (!rtems_pipe_configured)                                         
    87d4:	0a00000d 	beq	8810 <rtems_pipe_initialize+0x4c>             
    return;                                                           
                                                                      
  if (rtems_pipe_semaphore)                                           
    87d8:	e59fc038 	ldr	ip, [pc, #56]	; 8818 <rtems_pipe_initialize+0x54><== NOT EXECUTED
    87dc:	e59c3000 	ldr	r3, [ip]                                      <== NOT EXECUTED
    87e0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    87e4:	1a000009 	bne	8810 <rtems_pipe_initialize+0x4c>             <== NOT EXECUTED
    return;                                                           
                                                                      
  rtems_status_code sc;                                               
  sc = rtems_semaphore_create(                                        
    87e8:	e59f002c 	ldr	r0, [pc, #44]	; 881c <rtems_pipe_initialize+0x58><== NOT EXECUTED
    87ec:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    87f0:	e3a02054 	mov	r2, #84	; 0x54                                <== NOT EXECUTED
    87f4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
    87f8:	ebfff1d5 	bl	4f54 <rtems_semaphore_create>                  <== NOT EXECUTED
        rtems_build_name ('P', 'I', 'P', 'E'), 1,                     
        RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
        RTEMS_NO_PRIORITY, &rtems_pipe_semaphore);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
    87fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    rtems_fatal_error_occurred (sc);                                  
    8800:	1bfff3e8 	blne	57a8 <rtems_fatal_error_occurred>            <== NOT EXECUTED
                                                                      
  rtems_interval now;                                                 
  now = rtems_clock_get_ticks_since_boot();                           
    8804:	ebfff0d8 	bl	4b6c <rtems_clock_get_ticks_since_boot>        <== NOT EXECUTED
  rtems_pipe_no = now;                                                
    8808:	e59f3010 	ldr	r3, [pc, #16]	; 8820 <rtems_pipe_initialize+0x5c><== NOT EXECUTED
    880c:	e1c300b0 	strh	r0, [r3]                                     <== NOT EXECUTED
}                                                                     
    8810:	e8bd8008 	pop	{r3, pc}                                      
                                                                      

0003c2ac <rtems_rfs_bitmap_close>: return rtems_rfs_bitmap_create_search (control); } int rtems_rfs_bitmap_close (rtems_rfs_bitmap_control* control) {
   3c2ac:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  free (control->search_bits);                                        
   3c2b0:	e5900014 	ldr	r0, [r0, #20]                                 <== NOT EXECUTED
   3c2b4:	ebff2cfe 	bl	76b4 <free>                                    <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   3c2b8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3c2bc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

0003c310 <rtems_rfs_bitmap_create_search>: return 0; } int rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control) {
   3c310:	e92d45f1 	push	{r0, r4, r5, r6, r7, r8, sl, lr}             <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  size_t               size;                                          
  rtems_rfs_bitmap_bit bit;                                           
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c314:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)    
{                                                                     
   3c318:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  size_t               size;                                          
  rtems_rfs_bitmap_bit bit;                                           
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c31c:	ebffffe7 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c320:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c324:	ca000021 	bgt	3c3b0 <rtems_rfs_bitmap_create_search+0xa0>   <== NOT EXECUTED
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
  search_map = control->search_bits;                                  
   3c328:	e594c014 	ldr	ip, [r4, #20]                                 <== NOT EXECUTED
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
   3c32c:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
   3c330:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   3c334:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
  search_map = control->search_bits;                                  
  size = control->size;                                               
   3c338:	e594000c 	ldr	r0, [r4, #12]                                 <== NOT EXECUTED
{                                                                     
  /*                                                                  
   * Use the normal bit operators because we do not change the bits just merge
   * the 2 separate parts.                                            
   */                                                                 
  bits1 &= mask;                                                      
   3c33c:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
  control->free = 0;                                                  
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
   3c340:	e58c2000 	str	r2, [ip]                                      <== NOT EXECUTED
   3c344:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
      rtems_rfs_bitmap_set (*search_map, bit);                        
    else                                                              
    {                                                                 
      int b;                                                          
      for (b = 0; b < available; b++)                                 
        if (!rtems_rfs_bitmap_test (bits, b))                         
   3c348:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
  while (size)                                                        
   3c34c:	ea000015 	b	3c3a8 <rtems_rfs_bitmap_create_search+0x98>     <== NOT EXECUTED
  {                                                                   
    rtems_rfs_bitmap_element bits;                                    
    int                      available;                               
    if (size < rtems_rfs_bitmap_element_bits ())                      
   3c350:	e350001f 	cmp	r0, #31                                       <== NOT EXECUTED
   3c354:	e5916000 	ldr	r6, [r1]                                      <== NOT EXECUTED
{                                                                     
  /*                                                                  
   * Use the normal bit operators because we do not change the bits just merge
   * the 2 separate parts.                                            
   */                                                                 
  bits1 &= mask;                                                      
   3c358:	92602020 	rsbls	r2, r0, #32                                 <== NOT EXECUTED
   3c35c:	90066237 	andls	r6, r6, r7, lsr r2                          <== NOT EXECUTED
    if (size < rtems_rfs_bitmap_element_bits ())                      
    {                                                                 
      bits = rtems_rfs_bitmap_merge (*map,                            
                                     RTEMS_RFS_BITMAP_ELEMENT_SET,    
                                     rtems_rfs_bitmap_mask_section (0, size));
      available = size;                                               
   3c360:	91a05000 	movls	r5, r0                                      <== NOT EXECUTED
    }                                                                 
    else                                                              
    {                                                                 
      bits      = *map;                                               
   3c364:	83a05020 	movhi	r5, #32                                     <== NOT EXECUTED
      available = rtems_rfs_bitmap_element_bits ();                   
    }                                                                 
                                                                      
    if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))  
   3c368:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   3c36c:	0a000007 	beq	3c390 <rtems_rfs_bitmap_create_search+0x80>   <== NOT EXECUTED
   3c370:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
      rtems_rfs_bitmap_set (*search_map, bit);                        
    else                                                              
    {                                                                 
      int b;                                                          
      for (b = 0; b < available; b++)                                 
        if (!rtems_rfs_bitmap_test (bits, b))                         
   3c374:	e016a218 	ands	sl, r6, r8, lsl r2                           <== NOT EXECUTED
          control->free++;                                            
   3c378:	1594a010 	ldrne	sl, [r4, #16]                               <== NOT EXECUTED
    if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))  
      rtems_rfs_bitmap_set (*search_map, bit);                        
    else                                                              
    {                                                                 
      int b;                                                          
      for (b = 0; b < available; b++)                                 
   3c37c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
        if (!rtems_rfs_bitmap_test (bits, b))                         
          control->free++;                                            
   3c380:	128aa001 	addne	sl, sl, #1                                  <== NOT EXECUTED
   3c384:	1584a010 	strne	sl, [r4, #16]                               <== NOT EXECUTED
    if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))  
      rtems_rfs_bitmap_set (*search_map, bit);                        
    else                                                              
    {                                                                 
      int b;                                                          
      for (b = 0; b < available; b++)                                 
   3c388:	e1520005 	cmp	r2, r5                                        <== NOT EXECUTED
   3c38c:	bafffff8 	blt	3c374 <rtems_rfs_bitmap_create_search+0x64>   <== NOT EXECUTED
          control->free++;                                            
    }                                                                 
                                                                      
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
   3c390:	e3530020 	cmp	r3, #32                                       <== NOT EXECUTED
    {                                                                 
      bit = 0;                                                        
      search_map++;                                                   
      *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                   
   3c394:	05ac7004 	streq	r7, [ip, #4]!                               <== NOT EXECUTED
   3c398:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
    }                                                                 
    else                                                              
      bit++;                                                          
   3c39c:	12833001 	addne	r3, r3, #1                                  <== NOT EXECUTED
      for (b = 0; b < available; b++)                                 
        if (!rtems_rfs_bitmap_test (bits, b))                         
          control->free++;                                            
    }                                                                 
                                                                      
    size -= available;                                                
   3c3a0:	e0650000 	rsb	r0, r5, r0                                    <== NOT EXECUTED
   3c3a4:	e2811004 	add	r1, r1, #4                                    <== NOT EXECUTED
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
  while (size)                                                        
   3c3a8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c3ac:	1affffe7 	bne	3c350 <rtems_rfs_bitmap_create_search+0x40>   <== NOT EXECUTED
      bit++;                                                          
    map++;                                                            
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   3c3b0:	e8bd85f8 	pop	{r3, r4, r5, r6, r7, r8, sl, pc}              <== NOT EXECUTED
                                                                      

0003c2c0 <rtems_rfs_bitmap_load_map>: rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_map* map) { int rc; if (!control->buffer)
   3c2c0:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
   3c2c4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
 * @return int The error number (errno). No error if 0.               
 */                                                                   
static int                                                            
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,         
                           rtems_rfs_bitmap_map*     map)             
{                                                                     
   3c2c8:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   3c2cc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   3c2d0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
   3c2d4:	03a00006 	moveq	r0, #6                                      <== NOT EXECUTED
   3c2d8:	08bd8030 	popeq	{r4, r5, pc}                                <== NOT EXECUTED
    return ENXIO;                                                     
                                                                      
  *map = NULL;                                                        
   3c2dc:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   3c2e0:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_handle_request (control->fs,                  
   3c2e4:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
   3c2e8:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   3c2ec:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
   3c2f0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3c2f4:	ebffe0f9 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                        control->buffer,              
                                        control->block,               
                                        true);                        
  if (rc)                                                             
   3c2f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rc;                                                        
                                                                      
  *map = rtems_rfs_buffer_data (control->buffer);                     
   3c2fc:	05943000 	ldreq	r3, [r4]                                    <== NOT EXECUTED
   3c300:	05933008 	ldreq	r3, [r3, #8]                                <== NOT EXECUTED
   3c304:	05933020 	ldreq	r3, [r3, #32]                               <== NOT EXECUTED
   3c308:	05853000 	streq	r3, [r5]                                    <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   3c30c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

0003c888 <rtems_rfs_bitmap_map_alloc>: int rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit seed, bool* allocated, rtems_rfs_bitmap_bit* bit) {
   3c888:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
   3c88c:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
  int                  rc = 0;                                        
                                                                      
  /*                                                                  
   * By default we assume the allocation failed.                      
   */                                                                 
  *allocated = false;                                                 
   3c890:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   3c894:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   3c898:	e5c72000 	strb	r2, [r7]                                     <== NOT EXECUTED
int                                                                   
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,        
                            rtems_rfs_bitmap_bit      seed,           
                            bool*                     allocated,      
                            rtems_rfs_bitmap_bit*     bit)            
{                                                                     
   3c89c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   3c8a0:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  int                  rc = 0;                                        
                                                                      
  /*                                                                  
   * By default we assume the allocation failed.                      
   */                                                                 
  *allocated = false;                                                 
   3c8a4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   * we have searched all of the map. The seed may not be aligned to a window
   * boundary so we may need to search a partial window and this may also not
   * be balanced for the upper or lower seeds. We move to the limits, search
   * then return false if no clear bits are found.                    
   */                                                                 
  while (((upper_seed >= 0) && (upper_seed < control->size))          
   3c8a8:	ea00001f 	b	3c92c <rtems_rfs_bitmap_map_alloc+0xa4>         <== NOT EXECUTED
         || ((lower_seed >= 0) && (lower_seed < control->size)))      
  {                                                                   
    /*                                                                
     * Search up first so bits allocated in succession are grouped together.
     */                                                               
    if (upper_seed < control->size)                                   
   3c8ac:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   3c8b0:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   3c8b4:	2a00000a 	bcs	3c8e4 <rtems_rfs_bitmap_map_alloc+0x5c>       <== NOT EXECUTED
    {                                                                 
      *bit = upper_seed;                                              
   3c8b8:	e5885000 	str	r5, [r8]                                      <== NOT EXECUTED
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
   3c8bc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3c8c0:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   3c8c4:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   3c8c8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3c8cc:	ebffff69 	bl	3c678 <T.57>                                   <== NOT EXECUTED
                                               window, 1);            
      if ((rc > 0) || *allocated)                                     
   3c8d0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c8d4:	ca00001e 	bgt	3c954 <rtems_rfs_bitmap_map_alloc+0xcc>       <== NOT EXECUTED
   3c8d8:	e5d73000 	ldrb	r3, [r7]                                     <== NOT EXECUTED
   3c8dc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3c8e0:	1a00001b 	bne	3c954 <rtems_rfs_bitmap_map_alloc+0xcc>       <== NOT EXECUTED
        break;                                                        
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
   3c8e4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3c8e8:	ba00000a 	blt	3c918 <rtems_rfs_bitmap_map_alloc+0x90>       <== NOT EXECUTED
    {                                                                 
      *bit = lower_seed;                                              
   3c8ec:	e5884000 	str	r4, [r8]                                      <== NOT EXECUTED
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
   3c8f0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3c8f4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   3c8f8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   3c8fc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   3c900:	ebffff5c 	bl	3c678 <T.57>                                   <== NOT EXECUTED
                                               window, -1);           
      if ((rc > 0) || *allocated)                                     
   3c904:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c908:	ca000011 	bgt	3c954 <rtems_rfs_bitmap_map_alloc+0xcc>       <== NOT EXECUTED
   3c90c:	e5d73000 	ldrb	r3, [r7]                                     <== NOT EXECUTED
   3c910:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3c914:	1a00000e 	bne	3c954 <rtems_rfs_bitmap_map_alloc+0xcc>       <== NOT EXECUTED
                                                                      
    /*                                                                
     * Do not bound the limits at the edges of the map. Do not update if an
     * edge has been passed.                                          
     */                                                               
    if (upper_seed < control->size)                                   
   3c918:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   3c91c:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
      upper_seed += window;                                           
   3c920:	32855b02 	addcc	r5, r5, #2048	; 0x800                       <== NOT EXECUTED
    if (lower_seed >= 0)                                              
   3c924:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
      lower_seed -= window;                                           
   3c928:	a2444b02 	subge	r4, r4, #2048	; 0x800                       <== NOT EXECUTED
   * we have searched all of the map. The seed may not be aligned to a window
   * boundary so we may need to search a partial window and this may also not
   * be balanced for the upper or lower seeds. We move to the limits, search
   * then return false if no clear bits are found.                    
   */                                                                 
  while (((upper_seed >= 0) && (upper_seed < control->size))          
   3c92c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   3c930:	ba000002 	blt	3c940 <rtems_rfs_bitmap_map_alloc+0xb8>       <== NOT EXECUTED
   3c934:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   3c938:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   3c93c:	3affffda 	bcc	3c8ac <rtems_rfs_bitmap_map_alloc+0x24>       <== NOT EXECUTED
   3c940:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   3c944:	ba000002 	blt	3c954 <rtems_rfs_bitmap_map_alloc+0xcc>       <== NOT EXECUTED
         || ((lower_seed >= 0) && (lower_seed < control->size)))      
   3c948:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   3c94c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
   3c950:	3affffd5 	bcc	3c8ac <rtems_rfs_bitmap_map_alloc+0x24>       <== NOT EXECUTED
    if (lower_seed >= 0)                                              
      lower_seed -= window;                                           
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   3c954:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   3c958:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0003c578 <rtems_rfs_bitmap_map_clear>: } int rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit bit) {
   3c578:	e92d4031 	push	{r0, r4, r5, lr}                             <== NOT EXECUTED
   3c57c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  rtems_rfs_bitmap_map search_map;                                    
  int                  index;                                         
  int                  offset;                                        
  int                  rc;                                            
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c580:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,        
                            rtems_rfs_bitmap_bit      bit)            
{                                                                     
   3c584:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  rtems_rfs_bitmap_map search_map;                                    
  int                  index;                                         
  int                  offset;                                        
  int                  rc;                                            
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c588:	ebffff4c 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c58c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c590:	ca000016 	bgt	3c5f0 <rtems_rfs_bitmap_map_clear+0x78>       <== NOT EXECUTED
    return rc;                                                        
  if (bit >= control->size)                                           
   3c594:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   3c598:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   3c59c:	23a00016 	movcs	r0, #22                                     <== NOT EXECUTED
   3c5a0:	2a000012 	bcs	3c5f0 <rtems_rfs_bitmap_map_clear+0x78>       <== NOT EXECUTED
    return EINVAL;                                                    
  search_map        = control->search_bits;                           
  index             = rtems_rfs_bitmap_map_index (bit);               
  offset            = rtems_rfs_bitmap_map_offset (bit);              
  map[index]        = rtems_rfs_bitmap_clear (map[index], 1 << offset);
   3c5a4:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
  if (rc > 0)                                                         
    return rc;                                                        
  if (bit >= control->size)                                           
    return EINVAL;                                                    
  search_map        = control->search_bits;                           
  index             = rtems_rfs_bitmap_map_index (bit);               
   3c5a8:	e1a022c5 	asr	r2, r5, #5                                    <== NOT EXECUTED
  offset            = rtems_rfs_bitmap_map_offset (bit);              
  map[index]        = rtems_rfs_bitmap_clear (map[index], 1 << offset);
   3c5ac:	e7910102 	ldr	r0, [r1, r2, lsl #2]                          <== NOT EXECUTED
   3c5b0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3c5b4:	e205c01f 	and	ip, r5, #31                                   <== NOT EXECUTED
   3c5b8:	e1800c13 	orr	r0, r0, r3, lsl ip                            <== NOT EXECUTED
   3c5bc:	e7810102 	str	r0, [r1, r2, lsl #2]                          <== NOT EXECUTED
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
  if (bit >= control->size)                                           
    return EINVAL;                                                    
  search_map        = control->search_bits;                           
   3c5c0:	e5941014 	ldr	r1, [r4, #20]                                 <== NOT EXECUTED
  offset            = rtems_rfs_bitmap_map_offset (bit);              
  map[index]        = rtems_rfs_bitmap_clear (map[index], 1 << offset);
  bit               = index;                                          
  index             = rtems_rfs_bitmap_map_index (bit);               
  offset            = rtems_rfs_bitmap_map_offset(bit);               
  search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
   3c5c4:	e1a05545 	asr	r5, r5, #10                                   <== NOT EXECUTED
   3c5c8:	e7910105 	ldr	r0, [r1, r5, lsl #2]                          <== NOT EXECUTED
   3c5cc:	e202201f 	and	r2, r2, #31                                   <== NOT EXECUTED
   3c5d0:	e1802213 	orr	r2, r0, r3, lsl r2                            <== NOT EXECUTED
   3c5d4:	e7812105 	str	r2, [r1, r5, lsl #2]                          <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (control->buffer);                      
  control->free++;                                                    
   3c5d8:	e5942010 	ldr	r2, [r4, #16]                                 <== NOT EXECUTED
  map[index]        = rtems_rfs_bitmap_clear (map[index], 1 << offset);
  bit               = index;                                          
  index             = rtems_rfs_bitmap_map_index (bit);               
  offset            = rtems_rfs_bitmap_map_offset(bit);               
  search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
  rtems_rfs_buffer_mark_dirty (control->buffer);                      
   3c5dc:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
  control->free++;                                                    
   3c5e0:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
  map[index]        = rtems_rfs_bitmap_clear (map[index], 1 << offset);
  bit               = index;                                          
  index             = rtems_rfs_bitmap_map_index (bit);               
  offset            = rtems_rfs_bitmap_map_offset(bit);               
  search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
  rtems_rfs_buffer_mark_dirty (control->buffer);                      
   3c5e4:	e5c13000 	strb	r3, [r1]                                     <== NOT EXECUTED
  control->free++;                                                    
   3c5e8:	e5842010 	str	r2, [r4, #16]                                 <== NOT EXECUTED
   3c5ec:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   3c5f0:	e8bd8038 	pop	{r3, r4, r5, pc}                              <== NOT EXECUTED
                                                                      

0003c3fc <rtems_rfs_bitmap_map_clear_all>: return 0; } int rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control) {
   3c3fc:	e92d4011 	push	{r0, r4, lr}                                 <== NOT EXECUTED
  rtems_rfs_bitmap_bit last_search_bit;                               
  size_t               elements;                                      
  int                  e;                                             
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c400:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)    
{                                                                     
   3c404:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_bit last_search_bit;                               
  size_t               elements;                                      
  int                  e;                                             
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c408:	ebffffac 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c40c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c410:	ca00001f 	bgt	3c494 <rtems_rfs_bitmap_map_clear_all+0x98>   <== NOT EXECUTED
    return rc;                                                        
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
   3c414:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
   3c418:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
   3c41c:	e1a012a1 	lsr	r1, r1, #5                                    <== NOT EXECUTED
   3c420:	e2813001 	add	r3, r1, #1                                    <== NOT EXECUTED
                                                                      
  control->free = elements;                                           
   3c424:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
                                                                      
  for (e = 0; e < elements; e++)                                      
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                          
   3c428:	e59dc000 	ldr	ip, [sp]                                      <== NOT EXECUTED
   3c42c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   3c430:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
                                                                      
  control->free = elements;                                           
                                                                      
  for (e = 0; e < elements; e++)                                      
   3c434:	ea000001 	b	3c440 <rtems_rfs_bitmap_map_clear_all+0x44>     <== NOT EXECUTED
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                          
   3c438:	e78c0102 	str	r0, [ip, r2, lsl #2]                          <== NOT EXECUTED
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
                                                                      
  control->free = elements;                                           
                                                                      
  for (e = 0; e < elements; e++)                                      
   3c43c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   3c440:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   3c444:	3afffffb 	bcc	3c438 <rtems_rfs_bitmap_map_clear_all+0x3c>   <== NOT EXECUTED
   * Set the un-mapped bits in the last search element so the available logic
   * works.                                                           
   */                                                                 
  last_search_bit = rtems_rfs_bitmap_map_offset (elements);           
                                                                      
  if (last_search_bit == 0)                                           
   3c448:	e213201f 	ands	r2, r3, #31                                  <== NOT EXECUTED
   3c44c:	03a02020 	moveq	r2, #32                                     <== NOT EXECUTED
    last_search_bit = rtems_rfs_bitmap_element_bits ();               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
   3c450:	e1a0c2a1 	lsr	ip, r1, #5                                    <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)    
   3c454:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    last_search_bit = rtems_rfs_bitmap_element_bits ();               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
                                                                      
  for (e = 0; e < (elements - 1); e++)                                
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;         
   3c458:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  if (last_search_bit == 0)                                           
    last_search_bit = rtems_rfs_bitmap_element_bits ();               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
                                                                      
  for (e = 0; e < (elements - 1); e++)                                
   3c45c:	ea000001 	b	3c468 <rtems_rfs_bitmap_map_clear_all+0x6c>     <== NOT EXECUTED
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;         
   3c460:	e7810103 	str	r0, [r1, r3, lsl #2]                          <== NOT EXECUTED
  if (last_search_bit == 0)                                           
    last_search_bit = rtems_rfs_bitmap_element_bits ();               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
                                                                      
  for (e = 0; e < (elements - 1); e++)                                
   3c464:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3c468:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c46c:	e5941014 	ldr	r1, [r4, #20]                                 <== NOT EXECUTED
   3c470:	1afffffa 	bne	3c460 <rtems_rfs_bitmap_map_clear_all+0x64>   <== NOT EXECUTED
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;         
                                                                      
  control->search_bits[elements - 1] =                                
   3c474:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   3c478:	e2622020 	rsb	r2, r2, #32                                   <== NOT EXECUTED
   3c47c:	e1a02230 	lsr	r2, r0, r2                                    <== NOT EXECUTED
    rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,           
                            RTEMS_RFS_BITMAP_ELEMENT_SET,             
                            rtems_rfs_bitmap_mask (last_search_bit)); 
                                                                      
  rtems_rfs_buffer_mark_dirty (control->buffer);                      
   3c480:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
  elements = rtems_rfs_bitmap_elements (elements);                    
                                                                      
  for (e = 0; e < (elements - 1); e++)                                
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;         
                                                                      
  control->search_bits[elements - 1] =                                
   3c484:	e7812103 	str	r2, [r1, r3, lsl #2]                          <== NOT EXECUTED
    rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,           
                            RTEMS_RFS_BITMAP_ELEMENT_SET,             
                            rtems_rfs_bitmap_mask (last_search_bit)); 
                                                                      
  rtems_rfs_buffer_mark_dirty (control->buffer);                      
   3c488:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3c48c:	e5c03000 	strb	r3, [r0]                                     <== NOT EXECUTED
   3c490:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   3c494:	e8bd8018 	pop	{r3, r4, pc}                                  <== NOT EXECUTED
                                                                      

0003c5f4 <rtems_rfs_bitmap_map_set>: } int rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit bit) {
   3c5f4:	e92d4031 	push	{r0, r4, r5, lr}                             <== NOT EXECUTED
   3c5f8:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  rtems_rfs_bitmap_map search_map;                                    
  int                  index;                                         
  int                  offset;                                        
  int                 rc;                                             
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c5fc:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,          
                          rtems_rfs_bitmap_bit      bit)              
{                                                                     
   3c600:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  rtems_rfs_bitmap_map search_map;                                    
  int                  index;                                         
  int                  offset;                                        
  int                 rc;                                             
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c604:	ebffff2d 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c608:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c60c:	ca000018 	bgt	3c674 <rtems_rfs_bitmap_map_set+0x80>         <== NOT EXECUTED
    return rc;                                                        
  if (bit >= control->size)                                           
   3c610:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   3c614:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   3c618:	23a00016 	movcs	r0, #22                                     <== NOT EXECUTED
   3c61c:	2a000014 	bcs	3c674 <rtems_rfs_bitmap_map_set+0x80>         <== NOT EXECUTED
    return EINVAL;                                                    
  search_map = control->search_bits;                                  
  index      = rtems_rfs_bitmap_map_index (bit);                      
  offset     = rtems_rfs_bitmap_map_offset (bit);                     
  map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);        
   3c620:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
  if (rc > 0)                                                         
    return rc;                                                        
  if (bit >= control->size)                                           
    return EINVAL;                                                    
  search_map = control->search_bits;                                  
  index      = rtems_rfs_bitmap_map_index (bit);                      
   3c624:	e1a022c5 	asr	r2, r5, #5                                    <== NOT EXECUTED
 */                                                                   
static rtems_rfs_bitmap_element                                       
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,                
                      rtems_rfs_bitmap_element bits)                  
{                                                                     
  return RTEMS_RFS_BITMAP_SET_BITS (target, bits);                    
   3c628:	e7910102 	ldr	r0, [r1, r2, lsl #2]                          <== NOT EXECUTED
   3c62c:	e205c01f 	and	ip, r5, #31                                   <== NOT EXECUTED
   3c630:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3c634:	e1c00c13 	bic	r0, r0, r3, lsl ip                            <== NOT EXECUTED
    return EINVAL;                                                    
  search_map = control->search_bits;                                  
  index      = rtems_rfs_bitmap_map_index (bit);                      
  offset     = rtems_rfs_bitmap_map_offset (bit);                     
  map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);        
  if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
   3c638:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  if (bit >= control->size)                                           
    return EINVAL;                                                    
  search_map = control->search_bits;                                  
  index      = rtems_rfs_bitmap_map_index (bit);                      
  offset     = rtems_rfs_bitmap_map_offset (bit);                     
  map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);        
   3c63c:	e7810102 	str	r0, [r1, r2, lsl #2]                          <== NOT EXECUTED
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
  if (bit >= control->size)                                           
    return EINVAL;                                                    
  search_map = control->search_bits;                                  
   3c640:	e5941014 	ldr	r1, [r4, #20]                                 <== NOT EXECUTED
  index      = rtems_rfs_bitmap_map_index (bit);                      
  offset     = rtems_rfs_bitmap_map_offset (bit);                     
  map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);        
  if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
   3c644:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
   3c648:	1a000009 	bne	3c674 <rtems_rfs_bitmap_map_set+0x80>         <== NOT EXECUTED
  {                                                                   
    bit = index;                                                      
    index  = rtems_rfs_bitmap_map_index (bit);                        
    offset = rtems_rfs_bitmap_map_offset (bit);                       
    search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
   3c64c:	e1a05545 	asr	r5, r5, #10                                   <== NOT EXECUTED
   3c650:	e791c105 	ldr	ip, [r1, r5, lsl #2]                          <== NOT EXECUTED
   3c654:	e202201f 	and	r2, r2, #31                                   <== NOT EXECUTED
   3c658:	e1cc2213 	bic	r2, ip, r3, lsl r2                            <== NOT EXECUTED
   3c65c:	e7812105 	str	r2, [r1, r5, lsl #2]                          <== NOT EXECUTED
    control->free--;                                                  
   3c660:	e5942010 	ldr	r2, [r4, #16]                                 <== NOT EXECUTED
    rtems_rfs_buffer_mark_dirty (control->buffer);                    
   3c664:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
  {                                                                   
    bit = index;                                                      
    index  = rtems_rfs_bitmap_map_index (bit);                        
    offset = rtems_rfs_bitmap_map_offset (bit);                       
    search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
    control->free--;                                                  
   3c668:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
    rtems_rfs_buffer_mark_dirty (control->buffer);                    
   3c66c:	e5c13000 	strb	r3, [r1]                                     <== NOT EXECUTED
  {                                                                   
    bit = index;                                                      
    index  = rtems_rfs_bitmap_map_index (bit);                        
    offset = rtems_rfs_bitmap_map_offset (bit);                       
    search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
    control->free--;                                                  
   3c670:	e5842010 	str	r2, [r4, #16]                                 <== NOT EXECUTED
    rtems_rfs_buffer_mark_dirty (control->buffer);                    
  }                                                                   
  return 0;                                                           
}                                                                     
   3c674:	e8bd8038 	pop	{r3, r4, r5, pc}                              <== NOT EXECUTED
                                                                      

0003c498 <rtems_rfs_bitmap_map_set_all>: return 0; } int rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control) {
   3c498:	e92d4011 	push	{r0, r4, lr}                                 <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  size_t               elements;                                      
  int                  e;                                             
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c49c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)      
{                                                                     
   3c4a0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  size_t               elements;                                      
  int                  e;                                             
  int                  rc;                                            
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c4a4:	ebffff85 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c4a8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c4ac:	ca00001a 	bgt	3c51c <rtems_rfs_bitmap_map_set_all+0x84>     <== NOT EXECUTED
    return rc;                                                        
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
   3c4b0:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
   3c4b4:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
  control->free = 0;                                                  
   3c4b8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
   3c4bc:	e1a022a2 	lsr	r2, r2, #5                                    <== NOT EXECUTED
                                                                      
  control->free = 0;                                                  
                                                                      
  for (e = 0; e < elements; e++)                                      
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;                            
   3c4c0:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
                                                                      
  control->free = 0;                                                  
   3c4c4:	e5841010 	str	r1, [r4, #16]                                 <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
   3c4c8:	e282c001 	add	ip, r2, #1                                    <== NOT EXECUTED
                                                                      
  control->free = 0;                                                  
                                                                      
  for (e = 0; e < elements; e++)                                      
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;                            
   3c4cc:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
                                                                      
  control->free = 0;                                                  
                                                                      
  for (e = 0; e < elements; e++)                                      
   3c4d0:	ea000001 	b	3c4dc <rtems_rfs_bitmap_map_set_all+0x44>       <== NOT EXECUTED
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;                            
   3c4d4:	e7801103 	str	r1, [r0, r3, lsl #2]                          <== NOT EXECUTED
                                                                      
  elements = rtems_rfs_bitmap_elements (control->size);               
                                                                      
  control->free = 0;                                                  
                                                                      
  for (e = 0; e < elements; e++)                                      
   3c4d8:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3c4dc:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
   3c4e0:	3afffffb 	bcc	3c4d4 <rtems_rfs_bitmap_map_set_all+0x3c>     <== NOT EXECUTED
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;                            
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
   3c4e4:	e1a022a2 	lsr	r2, r2, #5                                    <== NOT EXECUTED
   3c4e8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   3c4ec:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
  for (e = 0; e < elements; e++)                                      
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;           
   3c4f0:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
  for (e = 0; e < elements; e++)                                      
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;                            
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
                                                                      
  for (e = 0; e < elements; e++)                                      
   3c4f4:	ea000002 	b	3c504 <rtems_rfs_bitmap_map_set_all+0x6c>       <== NOT EXECUTED
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;           
   3c4f8:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
   3c4fc:	e7801103 	str	r1, [r0, r3, lsl #2]                          <== NOT EXECUTED
  for (e = 0; e < elements; e++)                                      
    map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;                            
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
                                                                      
  for (e = 0; e < elements; e++)                                      
   3c500:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3c504:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   3c508:	3afffffa 	bcc	3c4f8 <rtems_rfs_bitmap_map_set_all+0x60>     <== NOT EXECUTED
    control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;           
                                                                      
  rtems_rfs_buffer_mark_dirty (control->buffer);                      
   3c50c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   3c510:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3c514:	e5c32000 	strb	r2, [r3]                                     <== NOT EXECUTED
   3c518:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   3c51c:	e8bd8018 	pop	{r3, r4, pc}                                  <== NOT EXECUTED
                                                                      

0003c520 <rtems_rfs_bitmap_map_test>: int rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit bit, bool* state) {
   3c520:	e92d4071 	push	{r0, r4, r5, r6, lr}                         <== NOT EXECUTED
   3c524:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  int                  index;                                         
  int                  rc;                                            
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c528:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,         
                           rtems_rfs_bitmap_bit      bit,             
                           bool*                     state)           
{                                                                     
   3c52c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   3c530:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map map;                                           
  int                  index;                                         
  int                  rc;                                            
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
   3c534:	ebffff61 	bl	3c2c0 <rtems_rfs_bitmap_load_map>              <== NOT EXECUTED
  if (rc > 0)                                                         
   3c538:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c53c:	ca00000c 	bgt	3c574 <rtems_rfs_bitmap_map_test+0x54>        <== NOT EXECUTED
    return rc;                                                        
  if (bit >= control->size)                                           
   3c540:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   3c544:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
   3c548:	23a00016 	movcs	r0, #22                                     <== NOT EXECUTED
   3c54c:	2a000008 	bcs	3c574 <rtems_rfs_bitmap_map_test+0x54>        <== NOT EXECUTED
    return EINVAL;                                                    
  index = rtems_rfs_bitmap_map_index (bit);                           
  *state = rtems_rfs_bitmap_test (map[index], bit);                   
   3c550:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   3c554:	e1a022c4 	asr	r2, r4, #5                                    <== NOT EXECUTED
   3c558:	e7933102 	ldr	r3, [r3, r2, lsl #2]                          <== NOT EXECUTED
   3c55c:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3c560:	e0133412 	ands	r3, r3, r2, lsl r4                           <== NOT EXECUTED
   3c564:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   3c568:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   3c56c:	e5c53000 	strb	r3, [r5]                                     <== NOT EXECUTED
   3c570:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   3c574:	e8bd8078 	pop	{r3, r4, r5, r6, pc}                          <== NOT EXECUTED
                                                                      

0003c27c <rtems_rfs_bitmap_mask>: return 0; } rtems_rfs_bitmap_element rtems_rfs_bitmap_mask (unsigned int size) {
   3c27c:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   3c280:	e2600020 	rsb	r0, r0, #32                                   <== NOT EXECUTED
  rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; 
  mask >>= (rtems_rfs_bitmap_element_bits () - size);                 
  return mask;                                                        
}                                                                     
   3c284:	e1a00033 	lsr	r0, r3, r0                                    <== NOT EXECUTED
   3c288:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0003c28c <rtems_rfs_bitmap_mask_section>: rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end) { rtems_rfs_bitmap_element mask = 0; if (end > start)
   3c28c:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
    mask = rtems_rfs_bitmap_mask (end - start) << start;              
   3c290:	80601001 	rsbhi	r1, r0, r1                                  <== NOT EXECUTED
   3c294:	82611020 	rsbhi	r1, r1, #32                                 <== NOT EXECUTED
   3c298:	83e03000 	mvnhi	r3, #0                                      <== NOT EXECUTED
   3c29c:	81a01133 	lsrhi	r1, r3, r1                                  <== NOT EXECUTED
                                                                      
rtems_rfs_bitmap_element                                              
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)  
{                                                                     
  rtems_rfs_bitmap_element mask = 0;                                  
  if (end > start)                                                    
   3c2a0:	93a00000 	movls	r0, #0                                      <== NOT EXECUTED
    mask = rtems_rfs_bitmap_mask (end - start) << start;              
   3c2a4:	81a00011 	lslhi	r0, r1, r0                                  <== NOT EXECUTED
  return mask;                                                        
}                                                                     
   3c2a8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0003c3b4 <rtems_rfs_bitmap_open>: rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control, rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* buffer, size_t size, rtems_rfs_buffer_block block) {
   3c3b4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  control->fs = fs;                                                   
  control->block = block;                                             
  control->size = size;                                               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
   3c3b8:	e243c001 	sub	ip, r3, #1                                    <== NOT EXECUTED
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,             
                       rtems_rfs_file_system*    fs,                  
                       rtems_rfs_buffer_handle*  buffer,              
                       size_t                    size,                
                       rtems_rfs_buffer_block    block)               
{                                                                     
   3c3bc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  control->fs = fs;                                                   
  control->block = block;                                             
  control->size = size;                                               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
   3c3c0:	e1a0c52c 	lsr	ip, ip, #10                                   <== NOT EXECUTED
                       size_t                    size,                
                       rtems_rfs_buffer_block    block)               
{                                                                     
  size_t elements = rtems_rfs_bitmap_elements (size);                 
                                                                      
  control->buffer = buffer;                                           
   3c3c4:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
  control->fs = fs;                                                   
  control->block = block;                                             
   3c3c8:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
  control->size = size;                                               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
   3c3cc:	e28c0001 	add	r0, ip, #1                                    <== NOT EXECUTED
                       rtems_rfs_buffer_block    block)               
{                                                                     
  size_t elements = rtems_rfs_bitmap_elements (size);                 
                                                                      
  control->buffer = buffer;                                           
  control->fs = fs;                                                   
   3c3d0:	e984000e 	stmib	r4, {r1, r2, r3}                            <== NOT EXECUTED
  control->block = block;                                             
  control->size = size;                                               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
   3c3d4:	e1a00100 	lsl	r0, r0, #2                                    <== NOT EXECUTED
   3c3d8:	ebff2e5c 	bl	7d50 <malloc>                                  <== NOT EXECUTED
                                                                      
  if (!control->search_bits)                                          
   3c3dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  control->fs = fs;                                                   
  control->block = block;                                             
  control->size = size;                                               
                                                                      
  elements = rtems_rfs_bitmap_elements (elements);                    
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
   3c3e0:	e5840014 	str	r0, [r4, #20]                                 <== NOT EXECUTED
                                                                      
  if (!control->search_bits)                                          
   3c3e4:	1a000001 	bne	3c3f0 <rtems_rfs_bitmap_open+0x3c>            <== NOT EXECUTED
    return ENOMEM;                                                    
                                                                      
  return rtems_rfs_bitmap_create_search (control);                    
}                                                                     
   3c3e8:	e280000c 	add	r0, r0, #12                                   <== NOT EXECUTED
   3c3ec:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
                                                                      
  if (!control->search_bits)                                          
    return ENOMEM;                                                    
                                                                      
  return rtems_rfs_bitmap_create_search (control);                    
   3c3f0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
   3c3f4:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
  control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
                                                                      
  if (!control->search_bits)                                          
    return ENOMEM;                                                    
                                                                      
  return rtems_rfs_bitmap_create_search (control);                    
   3c3f8:	eaffffc4 	b	3c310 <rtems_rfs_bitmap_create_search>          <== NOT EXECUTED
                                                                      

00033640 <rtems_rfs_block_find_indirect>: rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* buffer, rtems_rfs_block_no block, int offset, rtems_rfs_block_no* result) {
   33640:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   33644:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the handle has a buffer and this request is a different block the current
   * buffer is released.                                              
   */                                                                 
  rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);     
   33648:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* buffer,       
                               rtems_rfs_block_no       block,        
                               int                      offset,       
                               rtems_rfs_block_no*      result)       
{                                                                     
   3364c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   33650:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
   33654:	e59d5014 	ldr	r5, [sp, #20]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the handle has a buffer and this request is a different block the current
   * buffer is released.                                              
   */                                                                 
  rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);     
   33658:	eb000420 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
  if (rc > 0)                                                         
   3365c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33660:	c8bd80f0 	popgt	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
    return rc;                                                        
                                                                      
  *result = rtems_rfs_block_get_number (buffer, offset);              
   33664:	e5973008 	ldr	r3, [r7, #8]                                  <== NOT EXECUTED
   33668:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
   3366c:	e0821104 	add	r1, r2, r4, lsl #2                            <== NOT EXECUTED
   33670:	e7d20104 	ldrb	r0, [r2, r4, lsl #2]                         <== NOT EXECUTED
   33674:	e5d13003 	ldrb	r3, [r1, #3]                                 <== NOT EXECUTED
   33678:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   3367c:	e5d11001 	ldrb	r1, [r1, #1]                                 <== NOT EXECUTED
   33680:	e5d42002 	ldrb	r2, [r4, #2]                                 <== NOT EXECUTED
   33684:	e1833c00 	orr	r3, r3, r0, lsl #24                           <== NOT EXECUTED
   33688:	e1833801 	orr	r3, r3, r1, lsl #16                           <== NOT EXECUTED
   3368c:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
  if ((*result + 1) == 0)                                             
   33690:	e3730001 	cmn	r3, #1                                        <== NOT EXECUTED
   33694:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   33698:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
    *result = 0;                                                      
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
   3369c:	e5962004 	ldr	r2, [r6, #4]                                  <== NOT EXECUTED
   336a0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))                 
      printf ("rtems-rfs: block-find: invalid block in table:"        
              " block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
    *result = 0;                                                      
   336a4:	23a00000 	movcs	r0, #0                                      <== NOT EXECUTED
                                                                      
  *result = rtems_rfs_block_get_number (buffer, offset);              
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
   336a8:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))                 
      printf ("rtems-rfs: block-find: invalid block in table:"        
              " block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
    *result = 0;                                                      
   336ac:	25850000 	strcs	r0, [r5]                                    <== NOT EXECUTED
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   336b0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000335a0 <rtems_rfs_block_get_block_size>: void rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs, rtems_rfs_pos pos, rtems_rfs_block_size* size) {
   335a0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   335a4:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  if (pos == 0)                                                       
   335a8:	e1912002 	orrs	r2, r1, r2                                   <== NOT EXECUTED
                                                                      
void                                                                  
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,            
                                rtems_rfs_pos          pos,           
                                rtems_rfs_block_size*  size)          
{                                                                     
   335ac:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   335b0:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)            
{                                                                     
  size->count = 0;                                                    
  size->offset = 0;                                                   
   335b4:	05832004 	streq	r2, [r3, #4]                                <== NOT EXECUTED
 * @param size A pointer to the block size.                           
 */                                                                   
static inline void                                                    
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)            
{                                                                     
  size->count = 0;                                                    
   335b8:	05832000 	streq	r2, [r3]                                    <== NOT EXECUTED
  if (pos == 0)                                                       
   335bc:	08bd80f0 	popeq	{r4, r5, r6, r7, pc}                        <== NOT EXECUTED
    rtems_rfs_block_set_size_zero (size);                             
  else                                                                
  {                                                                   
    size->count  = pos / rtems_rfs_fs_block_size (fs) + 1;            
   335c0:	e5907008 	ldr	r7, [r0, #8]                                  <== NOT EXECUTED
   335c4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   335c8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   335cc:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   335d0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   335d4:	eb008a21 	bl	55e60 <__udivdi3>                              <== NOT EXECUTED
   335d8:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
   335dc:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
   335e0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   335e4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   335e8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   335ec:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   335f0:	eb008b2b 	bl	562a4 <__umoddi3>                              <== NOT EXECUTED
   335f4:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
   335f8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00033540 <rtems_rfs_block_get_bpos>: void rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs, rtems_rfs_pos pos, rtems_rfs_block_pos* bpos) {
   33540:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  bpos->bno  = pos / rtems_rfs_fs_block_size (fs);                    
   33544:	e5906008 	ldr	r6, [r0, #8]                                  <== NOT EXECUTED
                                                                      
void                                                                  
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,                  
                          rtems_rfs_pos          pos,                 
                          rtems_rfs_block_pos*   bpos)                
{                                                                     
   33548:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
  bpos->bno  = pos / rtems_rfs_fs_block_size (fs);                    
   3354c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
                                                                      
void                                                                  
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,                  
                          rtems_rfs_pos          pos,                 
                          rtems_rfs_block_pos*   bpos)                
{                                                                     
   33550:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
   33554:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  bpos->bno  = pos / rtems_rfs_fs_block_size (fs);                    
   33558:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   3355c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   33560:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   33564:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   33568:	eb008a3c 	bl	55e60 <__udivdi3>                              <== NOT EXECUTED
  bpos->boff = pos % rtems_rfs_fs_block_size (fs);                    
   3356c:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
void                                                                  
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,                  
                          rtems_rfs_pos          pos,                 
                          rtems_rfs_block_pos*   bpos)                
{                                                                     
  bpos->bno  = pos / rtems_rfs_fs_block_size (fs);                    
   33570:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
  bpos->boff = pos % rtems_rfs_fs_block_size (fs);                    
   33574:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   33578:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   3357c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   33580:	eb008b47 	bl	562a4 <__umoddi3>                              <== NOT EXECUTED
   33584:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
}                                                                     
   33588:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0003358c <rtems_rfs_block_get_pos>: rtems_rfs_pos rtems_rfs_block_get_pos (rtems_rfs_file_system* fs, rtems_rfs_block_pos* bpos) {
   3358c:	e5902008 	ldr	r2, [r0, #8]                                  <== NOT EXECUTED
   33590:	e8910009 	ldm	r1, {r0, r3}                                  <== NOT EXECUTED
  return (bpos->bno * rtems_rfs_fs_block_size (fs)) + bpos->boff;     
}                                                                     
   33594:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   33598:	e0203092 	mla	r0, r2, r0, r3                                <== NOT EXECUTED
   3359c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

000335fc <rtems_rfs_block_get_size>: rtems_rfs_block_get_size (rtems_rfs_file_system* fs, rtems_rfs_block_size* size) { uint32_t offset; uint64_t block_size; if (size->count == 0)
   335fc:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
   33600:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
rtems_rfs_pos                                                         
rtems_rfs_block_get_size (rtems_rfs_file_system* fs,                  
                          rtems_rfs_block_size*  size)                
{                                                                     
   33604:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  uint32_t offset;                                                    
  uint64_t block_size;                                                
  if (size->count == 0)                                               
   33608:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   3360c:	03a04000 	moveq	r4, #0                                      <== NOT EXECUTED
   33610:	0a000007 	beq	33634 <rtems_rfs_block_get_size+0x38>         <== NOT EXECUTED
    return 0;                                                         
  if (size->offset == 0)                                              
   33614:	e5912004 	ldr	r2, [r1, #4]                                  <== NOT EXECUTED
    offset = rtems_rfs_fs_block_size (fs);                            
  else                                                                
    offset = size->offset;                                            
  block_size = rtems_rfs_fs_block_size (fs);                          
  return (((uint64_t) (size->count - 1)) * block_size) + offset;      
   33618:	e590c008 	ldr	ip, [r0, #8]                                  <== NOT EXECUTED
{                                                                     
  uint32_t offset;                                                    
  uint64_t block_size;                                                
  if (size->count == 0)                                               
    return 0;                                                         
  if (size->offset == 0)                                              
   3361c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    offset = rtems_rfs_fs_block_size (fs);                            
  else                                                                
    offset = size->offset;                                            
  block_size = rtems_rfs_fs_block_size (fs);                          
  return (((uint64_t) (size->count - 1)) * block_size) + offset;      
   33620:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
  uint32_t offset;                                                    
  uint64_t block_size;                                                
  if (size->count == 0)                                               
    return 0;                                                         
  if (size->offset == 0)                                              
    offset = rtems_rfs_fs_block_size (fs);                            
   33624:	05902008 	ldreq	r2, [r0, #8]                                <== NOT EXECUTED
  else                                                                
    offset = size->offset;                                            
  block_size = rtems_rfs_fs_block_size (fs);                          
  return (((uint64_t) (size->count - 1)) * block_size) + offset;      
   33628:	e0810c93 	umull	r0, r1, r3, ip                              <== NOT EXECUTED
   3362c:	e0903002 	adds	r3, r0, r2                                   <== NOT EXECUTED
   33630:	e2a14000 	adc	r4, r1, #0                                    <== NOT EXECUTED
}                                                                     
   33634:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33638:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   3363c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

000340d8 <rtems_rfs_block_map_close>: rtems_rfs_block_map* map) { int rc = 0; int brc; if (map->dirty && map->inode)
   340d8:	e5d13000 	ldrb	r3, [r1]                                     <== NOT EXECUTED
   340dc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,                 
                           rtems_rfs_block_map*   map)                
{                                                                     
   340e0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   340e4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   340e8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
   340ec:	0a00005a 	beq	3425c <rtems_rfs_block_map_close+0x184>       <== NOT EXECUTED
   340f0:	e5911004 	ldr	r1, [r1, #4]                                  <== NOT EXECUTED
   340f4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   340f8:	0a000057 	beq	3425c <rtems_rfs_block_map_close+0x184>       <== NOT EXECUTED
  {                                                                   
    brc = rtems_rfs_inode_load (fs, map->inode);                      
   340fc:	eb000e0a 	bl	3792c <rtems_rfs_inode_load>                   <== NOT EXECUTED
    if (brc > 0)                                                      
   34100:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   34104:	ca000055 	bgt	34260 <rtems_rfs_block_map_close+0x188>       <== NOT EXECUTED
   34108:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3410c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   34110:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
    if (rc == 0)                                                      
    {                                                                 
      int b;                                                          
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
        rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);    
   34114:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
   34118:	e5901024 	ldr	r1, [r0, #36]	; 0x24                          <== NOT EXECUTED
 * @param bno The block number.                                       
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
   3411c:	e592e00c 	ldr	lr, [r2, #12]                                 <== NOT EXECUTED
   34120:	e1a06c21 	lsr	r6, r1, #24                                   <== NOT EXECUTED
   34124:	e08ee003 	add	lr, lr, r3                                    <== NOT EXECUTED
   34128:	e5ce601c 	strb	r6, [lr, #28]                                <== NOT EXECUTED
   3412c:	e592e00c 	ldr	lr, [r2, #12]                                 <== NOT EXECUTED
   34130:	e1a06821 	lsr	r6, r1, #16                                   <== NOT EXECUTED
   34134:	e08ee003 	add	lr, lr, r3                                    <== NOT EXECUTED
   34138:	e5ce601d 	strb	r6, [lr, #29]                                <== NOT EXECUTED
   3413c:	e592e00c 	ldr	lr, [r2, #12]                                 <== NOT EXECUTED
   34140:	e1a06421 	lsr	r6, r1, #8                                    <== NOT EXECUTED
   34144:	e08ee003 	add	lr, lr, r3                                    <== NOT EXECUTED
   34148:	e5ce601e 	strb	r6, [lr, #30]                                <== NOT EXECUTED
   3414c:	e592e00c 	ldr	lr, [r2, #12]                                 <== NOT EXECUTED
   34150:	e08ee003 	add	lr, lr, r3                                    <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   34154:	e2833004 	add	r3, r3, #4                                    <== NOT EXECUTED
                                                                      
    if (rc == 0)                                                      
    {                                                                 
      int b;                                                          
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
   34158:	e3530014 	cmp	r3, #20                                       <== NOT EXECUTED
 * @param bno The block number.                                       
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
   3415c:	e5ce101f 	strb	r1, [lr, #31]                                <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   34160:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
   34164:	e5c2c010 	strb	ip, [r2, #16]                                <== NOT EXECUTED
   34168:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3416c:	1affffe8 	bne	34114 <rtems_rfs_block_map_close+0x3c>        <== NOT EXECUTED
        rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);    
      rtems_rfs_inode_set_block_count (map->inode, map->size.count);  
   34170:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
   34174:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
 * @param block_count The block count.                                
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->block_count, block_count);      
   34178:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
   3417c:	e1a0cc21 	lsr	ip, r1, #24                                   <== NOT EXECUTED
   34180:	e5c0c00c 	strb	ip, [r0, #12]                                <== NOT EXECUTED
   34184:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
   34188:	e1a0c821 	lsr	ip, r1, #16                                   <== NOT EXECUTED
   3418c:	e5c0c00d 	strb	ip, [r0, #13]                                <== NOT EXECUTED
   34190:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
   34194:	e1a0c421 	lsr	ip, r1, #8                                    <== NOT EXECUTED
   34198:	e5c0c00e 	strb	ip, [r0, #14]                                <== NOT EXECUTED
   3419c:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
   341a0:	e5c0100f 	strb	r1, [r0, #15]                                <== NOT EXECUTED
      rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
   341a4:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
   341a8:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,     
                                  uint16_t                block_offset)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);    
   341ac:	e590c00c 	ldr	ip, [r0, #12]                                 <== NOT EXECUTED
   341b0:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
   341b4:	e1a0ec21 	lsr	lr, r1, #24                                   <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->block_count, block_count);      
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   341b8:	e5c32010 	strb	r2, [r3, #16]                                <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,     
                                  uint16_t                block_offset)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);    
   341bc:	e5cce00a 	strb	lr, [ip, #10]                                <== NOT EXECUTED
   341c0:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
   341c4:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
   341c8:	e5c3100b 	strb	r1, [r3, #11]                                <== NOT EXECUTED
      rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
   341cc:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
   341d0:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
 * @param block_count The last map block number.                      
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
   341d4:	e591c00c 	ldr	ip, [r1, #12]                                 <== NOT EXECUTED
   341d8:	e1a0ec23 	lsr	lr, r3, #24                                   <== NOT EXECUTED
static inline void                                                    
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,     
                                  uint16_t                block_offset)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);    
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   341dc:	e5c02010 	strb	r2, [r0, #16]                                <== NOT EXECUTED
 * @param block_count The last map block number.                      
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
   341e0:	e5cce030 	strb	lr, [ip, #48]	; 0x30                         <== NOT EXECUTED
   341e4:	e591000c 	ldr	r0, [r1, #12]                                 <== NOT EXECUTED
   341e8:	e1a0c823 	lsr	ip, r3, #16                                   <== NOT EXECUTED
   341ec:	e5c0c031 	strb	ip, [r0, #49]	; 0x31                         <== NOT EXECUTED
   341f0:	e591000c 	ldr	r0, [r1, #12]                                 <== NOT EXECUTED
   341f4:	e1a0c423 	lsr	ip, r3, #8                                    <== NOT EXECUTED
   341f8:	e5c0c032 	strb	ip, [r0, #50]	; 0x32                         <== NOT EXECUTED
   341fc:	e591000c 	ldr	r0, [r1, #12]                                 <== NOT EXECUTED
   34200:	e5c03033 	strb	r3, [r0, #51]	; 0x33                         <== NOT EXECUTED
      rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
   34204:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
   34208:	e5940020 	ldr	r0, [r4, #32]                                 <== NOT EXECUTED
 * @param block_count The last data block number.                     
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
   3420c:	e593c00c 	ldr	ip, [r3, #12]                                 <== NOT EXECUTED
   34210:	e1a0ec20 	lsr	lr, r0, #24                                   <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   34214:	e5c12010 	strb	r2, [r1, #16]                                <== NOT EXECUTED
 * @param block_count The last data block number.                     
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
   34218:	e5cce034 	strb	lr, [ip, #52]	; 0x34                         <== NOT EXECUTED
   3421c:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
   34220:	e1a0c820 	lsr	ip, r0, #16                                   <== NOT EXECUTED
   34224:	e5c1c035 	strb	ip, [r1, #53]	; 0x35                         <== NOT EXECUTED
   34228:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
   3422c:	e1a0c420 	lsr	ip, r0, #8                                    <== NOT EXECUTED
   34230:	e5c1c036 	strb	ip, [r1, #54]	; 0x36                         <== NOT EXECUTED
   34234:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
   34238:	e5c10037 	strb	r0, [r1, #55]	; 0x37                         <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   3423c:	e5c32010 	strb	r2, [r3, #16]                                <== NOT EXECUTED
                                                                      
      brc = rtems_rfs_inode_unload (fs, map->inode, true);            
   34240:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34244:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
   34248:	eb000d80 	bl	37850 <rtems_rfs_inode_unload>                 <== NOT EXECUTED
      if (brc > 0)                                                    
        rc = brc;                                                     
                                                                      
      map->dirty = false;                                             
   3424c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   34250:	e5c43000 	strb	r3, [r4]                                     <== NOT EXECUTED
      rtems_rfs_inode_set_block_count (map->inode, map->size.count);  
      rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
      rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
      rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
                                                                      
      brc = rtems_rfs_inode_unload (fs, map->inode, true);            
   34254:	e1c07fc0 	bic	r7, r0, r0, asr #31                           <== NOT EXECUTED
   34258:	ea000000 	b	34260 <rtems_rfs_block_map_close+0x188>         <== NOT EXECUTED
      if (brc > 0)                                                    
        rc = brc;                                                     
                                                                      
      map->dirty = false;                                             
   3425c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  map->inode = NULL;                                                  
   34260:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   34264:	e2841038 	add	r1, r4, #56	; 0x38                            <== NOT EXECUTED
   34268:	e5846004 	str	r6, [r4, #4]                                  <== NOT EXECUTED
   3426c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34270:	eb0000d1 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   34274:	e5c46038 	strb	r6, [r4, #56]	; 0x38                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34278:	e584603c 	str	r6, [r4, #60]	; 0x3c                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   3427c:	e5846040 	str	r6, [r4, #64]	; 0x40                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   34280:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34284:	e2841044 	add	r1, r4, #68	; 0x44                            <== NOT EXECUTED
   34288:	eb0000cb 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   3428c:	e584604c 	str	r6, [r4, #76]	; 0x4c                          <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   34290:	e5c46044 	strb	r6, [r4, #68]	; 0x44                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34294:	e5846048 	str	r6, [r4, #72]	; 0x48                          <== NOT EXECUTED
    rc = brc;                                                         
  brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);      
  if ((brc > 0) && (rc == 0))                                         
    rc = brc;                                                         
  return rc;                                                          
}                                                                     
   34298:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   3429c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000336b4 <rtems_rfs_block_map_find>: int rtems_rfs_block_map_find (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, rtems_rfs_block_pos* bpos, rtems_rfs_block_no* block) {
   336b4:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
   336b8:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  *block = 0;                                                         
   336bc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   336c0:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Range checking here makes the remaining logic simpler.           
   */                                                                 
  if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))          
   336c4:	e592b000 	ldr	fp, [r2]                                      <== NOT EXECUTED
   336c8:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,                  
                          rtems_rfs_block_map*   map,                 
                          rtems_rfs_block_pos*   bpos,                
                          rtems_rfs_block_no*    block)               
{                                                                     
   336cc:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   336d0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   336d4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  *block = 0;                                                         
                                                                      
  /*                                                                  
   * Range checking here makes the remaining logic simpler.           
   */                                                                 
  if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))          
   336d8:	0a000002 	beq	336e8 <rtems_rfs_block_map_find+0x34>         <== NOT EXECUTED
   336dc:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
   336e0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   336e4:	0a000046 	beq	33804 <rtems_rfs_block_map_find+0x150>        <== NOT EXECUTED
   336e8:	e5948008 	ldr	r8, [r4, #8]                                  <== NOT EXECUTED
   336ec:	e15b0008 	cmp	fp, r8                                        <== NOT EXECUTED
   336f0:	2a000043 	bcs	33804 <rtems_rfs_block_map_find+0x150>        <== NOT EXECUTED
    return ENXIO;                                                     
                                                                      
  /*                                                                  
   * If the block position is the same and we have found the block just return it.
   */                                                                 
  if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))         
   336f4:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   336f8:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
   336fc:	1a000002 	bne	3370c <rtems_rfs_block_map_find+0x58>         <== NOT EXECUTED
   33700:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
   33704:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   33708:	1a000003 	bne	3371c <rtems_rfs_block_map_find+0x68>         <== NOT EXECUTED
    /*                                                                
     * Determine the type of access we need to perform. If the number of blocks
     * is less than or equal to the number of slots in the inode the blocks are
     * directly accessed.                                             
     */                                                               
    if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)                    
   3370c:	e3580005 	cmp	r8, #5                                        <== NOT EXECUTED
   33710:	8a000003 	bhi	33724 <rtems_rfs_block_map_find+0x70>         <== NOT EXECUTED
    {                                                                 
      *block = map->blocks[bpos->bno];                                
   33714:	e28bb009 	add	fp, fp, #9                                    <== NOT EXECUTED
   33718:	e794310b 	ldr	r3, [r4, fp, lsl #2]                          <== NOT EXECUTED
   3371c:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
   33720:	ea00002e 	b	337e0 <rtems_rfs_block_map_find+0x12c>          <== NOT EXECUTED
       * The map is either singly or doubly indirect.                 
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = bpos->bno % fs->blocks_per_block;                      
   33724:	e5969030 	ldr	r9, [r6, #48]	; 0x30                          <== NOT EXECUTED
   33728:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   3372c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   33730:	eb008644 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
      singly = bpos->bno / fs->blocks_per_block;                      
   33734:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
       * The map is either singly or doubly indirect.                 
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = bpos->bno % fs->blocks_per_block;                      
   33738:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
      singly = bpos->bno / fs->blocks_per_block;                      
   3373c:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   33740:	eb0085ac 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
   33744:	e5963034 	ldr	r3, [r6, #52]	; 0x34                          <== NOT EXECUTED
   33748:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = bpos->bno % fs->blocks_per_block;                      
      singly = bpos->bno / fs->blocks_per_block;                      
   3374c:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
   33750:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
   33754:	8a000005 	bhi	33770 <rtems_rfs_block_map_find+0xbc>         <== NOT EXECUTED
      {                                                               
        /*                                                            
         * This is a single indirect table of blocks anchored off a slot in the
         * inode.                                                     
         */                                                           
        rc = rtems_rfs_block_find_indirect (fs,                       
   33758:	e280b009 	add	fp, r0, #9                                    <== NOT EXECUTED
   3375c:	e794210b 	ldr	r2, [r4, fp, lsl #2]                          <== NOT EXECUTED
   33760:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   33764:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   33768:	e2841038 	add	r1, r4, #56	; 0x38                            <== NOT EXECUTED
   3376c:	ea000017 	b	337d0 <rtems_rfs_block_map_find+0x11c>          <== NOT EXECUTED
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
   33770:	e5963038 	ldr	r3, [r6, #56]	; 0x38                          <== NOT EXECUTED
   33774:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
   33778:	2a000021 	bcs	33804 <rtems_rfs_block_map_find+0x150>        <== NOT EXECUTED
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
   3377c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   33780:	eb008630 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
        {                                                             
          rc = rtems_rfs_block_find_indirect (fs,                     
   33784:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
   33788:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
        {                                                             
          rc = rtems_rfs_block_find_indirect (fs,                     
   3378c:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   33790:	eb008598 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
   33794:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
        {                                                             
          rc = rtems_rfs_block_find_indirect (fs,                     
   33798:	e2800009 	add	r0, r0, #9                                    <== NOT EXECUTED
   3379c:	e7942100 	ldr	r2, [r4, r0, lsl #2]                          <== NOT EXECUTED
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
   337a0:	e52c8004 	str	r8, [ip, #-4]!                                <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
        {                                                             
          rc = rtems_rfs_block_find_indirect (fs,                     
   337a4:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   337a8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   337ac:	e2841044 	add	r1, r4, #68	; 0x44                            <== NOT EXECUTED
   337b0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   337b4:	ebffffa1 	bl	33640 <rtems_rfs_block_find_indirect>          <== NOT EXECUTED
                                              &map->doubly_buffer,    
                                              map->blocks[doubly],    
                                              singly, &singly);       
          if (rc == 0)                                                
   337b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   337bc:	1a000011 	bne	33808 <rtems_rfs_block_map_find+0x154>        <== NOT EXECUTED
          {                                                           
            rc = rtems_rfs_block_find_indirect (fs,                   
   337c0:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
   337c4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   337c8:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   337cc:	e2841038 	add	r1, r4, #56	; 0x38                            <== NOT EXECUTED
   337d0:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
   337d4:	ebffff99 	bl	33640 <rtems_rfs_block_find_indirect>          <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
   337d8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   337dc:	1a000009 	bne	33808 <rtems_rfs_block_map_find+0x154>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
   337e0:	e5971008 	ldr	r1, [r7, #8]                                  <== NOT EXECUTED
   337e4:	e897000c 	ldm	r7, {r2, r3}                                  <== NOT EXECUTED
   337e8:	e5841018 	str	r1, [r4, #24]                                 <== NOT EXECUTED
   337ec:	e5842010 	str	r2, [r4, #16]                                 <== NOT EXECUTED
   337f0:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
    map->bpos.block = *block;                                         
   337f4:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   337f8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   337fc:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
   33800:	ea000000 	b	33808 <rtems_rfs_block_map_find+0x154>          <== NOT EXECUTED
   33804:	e3a00006 	mov	r0, #6                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   33808:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
                                                                      

00033c08 <rtems_rfs_block_map_free_all>: int rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs, rtems_rfs_block_map* map) { return rtems_rfs_block_map_shrink (fs, map, map->size.count);
   33c08:	e5912008 	ldr	r2, [r1, #8]                                  <== NOT EXECUTED
   33c0c:	eaffff4d 	b	33948 <rtems_rfs_block_map_shrink>              <== NOT EXECUTED
                                                                      

00033d28 <rtems_rfs_block_map_grow>: int rtems_rfs_block_map_grow (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks, rtems_rfs_block_no* new_block) {
   33d28:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   33d2c:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
   33d30:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
   33d34:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
            blocks, map->size.count);                                 
                                                                      
  if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
   33d38:	e5902038 	ldr	r2, [r0, #56]	; 0x38                          <== NOT EXECUTED
int                                                                   
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,                  
                          rtems_rfs_block_map*   map,                 
                          size_t                 blocks,              
                          rtems_rfs_block_no*    new_block)           
{                                                                     
   33d3c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
            blocks, map->size.count);                                 
                                                                      
  if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
   33d40:	e5911008 	ldr	r1, [r1, #8]                                  <== NOT EXECUTED
   33d44:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
   33d48:	e0801001 	add	r1, r0, r1                                    <== NOT EXECUTED
   33d4c:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,                  
                          rtems_rfs_block_map*   map,                 
                          size_t                 blocks,              
                          rtems_rfs_block_no*    new_block)           
{                                                                     
   33d50:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
            blocks, map->size.count);                                 
                                                                      
  if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
   33d54:	23a0a01b 	movcs	sl, #27                                     <== NOT EXECUTED
   33d58:	2a0000db 	bcs	340cc <rtems_rfs_block_map_grow+0x3a4>        <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   33d5c:	e2842044 	add	r2, r4, #68	; 0x44                            <== NOT EXECUTED
   33d60:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
                                                   &map->blocks[singly],
                                                   upping);           
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,  &map->singly_buffer,
   33d64:	e284b038 	add	fp, r4, #56	; 0x38                            <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   33d68:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   33d6c:	ea0000d0 	b	340b4 <rtems_rfs_block_map_grow+0x38c>          <== NOT EXECUTED
    /*                                                                
     * Allocate the block. If an indirect block is needed and cannot be
     * allocated free this block.                                     
     */                                                               
                                                                      
    rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,      
   33d70:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33d74:	e5941020 	ldr	r1, [r4, #32]                                 <== NOT EXECUTED
   33d78:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   33d7c:	e28d3018 	add	r3, sp, #24                                   <== NOT EXECUTED
   33d80:	eb000d57 	bl	372e4 <rtems_rfs_group_bitmap_alloc>           <== NOT EXECUTED
                                       false, &block);                
    if (rc > 0)                                                       
   33d84:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33d88:	ca0000ce 	bgt	340c8 <rtems_rfs_block_map_grow+0x3a0>        <== NOT EXECUTED
      return rc;                                                      
                                                                      
    if (map->size.count < RTEMS_RFS_INODE_BLOCKS)                     
   33d8c:	e5949008 	ldr	r9, [r4, #8]                                  <== NOT EXECUTED
   33d90:	e3590004 	cmp	r9, #4                                        <== NOT EXECUTED
      map->blocks[map->size.count] = block;                           
   33d94:	959d3018 	ldrls	r3, [sp, #24]                               <== NOT EXECUTED
   33d98:	92899009 	addls	r9, r9, #9                                  <== NOT EXECUTED
   33d9c:	97843109 	strls	r3, [r4, r9, lsl #2]                        <== NOT EXECUTED
    rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,      
                                       false, &block);                
    if (rc > 0)                                                       
      return rc;                                                      
                                                                      
    if (map->size.count < RTEMS_RFS_INODE_BLOCKS)                     
   33da0:	9a0000b5 	bls	3407c <rtems_rfs_block_map_grow+0x354>        <== NOT EXECUTED
       * Single indirect access is occuring. It could still be doubly indirect.
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = map->size.count % fs->blocks_per_block;                
   33da4:	e5956030 	ldr	r6, [r5, #48]	; 0x30                          <== NOT EXECUTED
   33da8:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   33dac:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   33db0:	eb0084a4 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
      singly = map->size.count / fs->blocks_per_block;                
   33db4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
       * Single indirect access is occuring. It could still be doubly indirect.
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = map->size.count % fs->blocks_per_block;                
   33db8:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
      singly = map->size.count / fs->blocks_per_block;                
   33dbc:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   33dc0:	eb00840c 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
      if (map->size.count < fs->block_map_singly_blocks)              
   33dc4:	e5953034 	ldr	r3, [r5, #52]	; 0x34                          <== NOT EXECUTED
   33dc8:	e1590003 	cmp	r9, r3                                        <== NOT EXECUTED
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = map->size.count % fs->blocks_per_block;                
      singly = map->size.count / fs->blocks_per_block;                
   33dcc:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
                                                                      
      if (map->size.count < fs->block_map_singly_blocks)              
   33dd0:	2a000017 	bcs	33e34 <rtems_rfs_block_map_grow+0x10c>        <== NOT EXECUTED
         * Singly indirect tables are being used. Allocate a new block for a
         * mapping table if direct is 0 or we are moving up (upping). If upping
         * move the direct blocks into the table and if not this is the first
         * entry of a new block.                                      
         */                                                           
        if ((direct == 0) ||                                          
   33dd4:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   33dd8:	0a000002 	beq	33de8 <rtems_rfs_block_map_grow+0xc0>         <== NOT EXECUTED
   33ddc:	e3570005 	cmp	r7, #5                                        <== NOT EXECUTED
   33de0:	03500000 	cmpeq	r0, #0                                      <== NOT EXECUTED
   33de4:	1a00000a 	bne	33e14 <rtems_rfs_block_map_grow+0xec>         <== NOT EXECUTED
          /*                                                          
           * Upping is when we move from direct to singly indirect.   
           */                                                         
          bool upping;                                                
          upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;         
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
   33de8:	e28a3009 	add	r3, sl, #9                                    <== NOT EXECUTED
   33dec:	e3590005 	cmp	r9, #5                                        <== NOT EXECUTED
   33df0:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
   33df4:	03a0c001 	moveq	ip, #1                                      <== NOT EXECUTED
   33df8:	e0843103 	add	r3, r4, r3, lsl #2                            <== NOT EXECUTED
   33dfc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33e00:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33e04:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   33e08:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   33e0c:	ebffff7f 	bl	33c10 <rtems_rfs_block_map_indirect_alloc>     <== NOT EXECUTED
         * Singly indirect tables are being used. Allocate a new block for a
         * mapping table if direct is 0 or we are moving up (upping). If upping
         * move the direct blocks into the table and if not this is the first
         * entry of a new block.                                      
         */                                                           
        if ((direct == 0) ||                                          
   33e10:	ea000005 	b	33e2c <rtems_rfs_block_map_grow+0x104>          <== NOT EXECUTED
                                                   &map->blocks[singly],
                                                   upping);           
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,  &map->singly_buffer,
   33e14:	e280a009 	add	sl, r0, #9                                    <== NOT EXECUTED
   33e18:	e794210a 	ldr	r2, [r4, sl, lsl #2]                          <== NOT EXECUTED
   33e1c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33e20:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   33e24:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   33e28:	eb00022c 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                                map->blocks[singly], true);
        }                                                             
                                                                      
        if (rc > 0)                                                   
   33e2c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33e30:	ea000072 	b	34000 <rtems_rfs_block_map_grow+0x2d8>          <== NOT EXECUTED
         * Doubly indirect tables are being used.                     
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no singly_block;                              
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
   33e34:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   33e38:	eb0083ee 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
   33e3c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
         * Doubly indirect tables are being used.                     
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no singly_block;                              
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
   33e40:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
   33e44:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   33e48:	eb00847e 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
         * Allocate a new block for a singly indirect table if direct is 0 as
         * it is the first entry of a new block. We may also need to allocate a
         * doubly indirect block as well. Both always occur when direct is 0
         * and the doubly indirect block when singly is 0.            
         */                                                           
        if (direct == 0)                                              
   33e4c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no singly_block;                              
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
   33e50:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
         * Allocate a new block for a singly indirect table if direct is 0 as
         * it is the first entry of a new block. We may also need to allocate a
         * doubly indirect block as well. Both always occur when direct is 0
         * and the doubly indirect block when singly is 0.            
         */                                                           
        if (direct == 0)                                              
   33e54:	1a00004f 	bne	33f98 <rtems_rfs_block_map_grow+0x270>        <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
   33e58:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33e5c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33e60:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   33e64:	e28d3014 	add	r3, sp, #20                                   <== NOT EXECUTED
   33e68:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
   33e6c:	ebffff67 	bl	33c10 <rtems_rfs_block_map_indirect_alloc>     <== NOT EXECUTED
                                                   &map->singly_buffer,
                                                   &singly_block,     
                                                   false);            
          if (rc > 0)                                                 
   33e70:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33e74:	c1a0a000 	movgt	sl, r0                                      <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
   33e78:	c1a01007 	movgt	r1, r7                                      <== NOT EXECUTED
   33e7c:	c1a00005 	movgt	r0, r5                                      <== NOT EXECUTED
   33e80:	ca000062 	bgt	34010 <rtems_rfs_block_map_grow+0x2e8>        <== NOT EXECUTED
                                                                      
          /*                                                          
           * Allocate a new block for a doubly indirect table if singly is 0 as
           * it is the first entry of a new singly indirect block.    
           */                                                         
          if ((singly == 0) ||                                        
   33e84:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   33e88:	0a000005 	beq	33ea4 <rtems_rfs_block_map_grow+0x17c>        <== NOT EXECUTED
   33e8c:	e3560005 	cmp	r6, #5                                        <== NOT EXECUTED
   33e90:	03590000 	cmpeq	r9, #0                                      <== NOT EXECUTED
   33e94:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   33e98:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   33e9c:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
   33ea0:	1a000013 	bne	33ef4 <rtems_rfs_block_map_grow+0x1cc>        <== NOT EXECUTED
              ((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))  
          {                                                           
            bool upping;                                              
            upping = map->size.count == fs->block_map_singly_blocks;  
            rc = rtems_rfs_block_map_indirect_alloc (fs, map,         
   33ea4:	e5952034 	ldr	r2, [r5, #52]	; 0x34                          <== NOT EXECUTED
   33ea8:	e594c008 	ldr	ip, [r4, #8]                                  <== NOT EXECUTED
   33eac:	e2893009 	add	r3, r9, #9                                    <== NOT EXECUTED
   33eb0:	e15c0002 	cmp	ip, r2                                        <== NOT EXECUTED
   33eb4:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
   33eb8:	03a0c001 	moveq	ip, #1                                      <== NOT EXECUTED
   33ebc:	e0843103 	add	r3, r4, r3, lsl #2                            <== NOT EXECUTED
   33ec0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33ec4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33ec8:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
   33ecc:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   33ed0:	ebffff4e 	bl	33c10 <rtems_rfs_block_map_indirect_alloc>     <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
                                                     upping);         
            if (rc > 0)                                               
   33ed4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33ed8:	da000015 	ble	33f34 <rtems_rfs_block_map_grow+0x20c>        <== NOT EXECUTED
   33edc:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
            {                                                         
              rtems_rfs_group_bitmap_free (fs, false, singly_block);  
   33ee0:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   33ee4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33ee8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   33eec:	eb000cdf 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
   33ef0:	ea000044 	b	34008 <rtems_rfs_block_map_grow+0x2e0>          <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   33ef4:	e2899009 	add	r9, r9, #9                                    <== NOT EXECUTED
   33ef8:	e7942109 	ldr	r2, [r4, r9, lsl #2]                          <== NOT EXECUTED
   33efc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33f00:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   33f04:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   33f08:	eb0001f4 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                                  map->blocks[doubly], true);
            if (rc > 0)                                               
   33f0c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33f10:	da000007 	ble	33f34 <rtems_rfs_block_map_grow+0x20c>        <== NOT EXECUTED
            {                                                         
              rtems_rfs_group_bitmap_free (fs, false, singly_block);  
   33f14:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
   33f18:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
   33f1c:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   33f20:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33f24:	eb000cd1 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
              rtems_rfs_group_bitmap_free (fs, false, block);         
   33f28:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33f2c:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
   33f30:	ea000036 	b	34010 <rtems_rfs_block_map_grow+0x2e8>          <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
                                                                      
          rtems_rfs_block_set_number (&map->doubly_buffer,            
   33f34:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   33f38:	e5dd2017 	ldrb	r2, [sp, #23]                                <== NOT EXECUTED
   33f3c:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   33f40:	e7c32106 	strb	r2, [r3, r6, lsl #2]                         <== NOT EXECUTED
   33f44:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   33f48:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
   33f4c:	e1dd11b6 	ldrh	r1, [sp, #22]                                <== NOT EXECUTED
   33f50:	e1a03106 	lsl	r3, r6, #2                                    <== NOT EXECUTED
   33f54:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
   33f58:	e5c21001 	strb	r1, [r2, #1]                                 <== NOT EXECUTED
   33f5c:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   33f60:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
   33f64:	e5922020 	ldr	r2, [r2, #32]                                 <== NOT EXECUTED
   33f68:	e1a06086 	lsl	r6, r6, #1                                    <== NOT EXECUTED
   33f6c:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   33f70:	e1a01421 	lsr	r1, r1, #8                                    <== NOT EXECUTED
   33f74:	e7c21086 	strb	r1, [r2, r6, lsl #1]                         <== NOT EXECUTED
   33f78:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   33f7c:	e5922020 	ldr	r2, [r2, #32]                                 <== NOT EXECUTED
   33f80:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
   33f84:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   33f88:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
   33f8c:	e5c32003 	strb	r2, [r3, #3]                                 <== NOT EXECUTED
   33f90:	e5c40044 	strb	r0, [r4, #68]	; 0x44                         <== NOT EXECUTED
   33f94:	ea000020 	b	3401c <rtems_rfs_block_map_grow+0x2f4>          <== NOT EXECUTED
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
   33f98:	e2899009 	add	r9, r9, #9                                    <== NOT EXECUTED
   33f9c:	e7942109 	ldr	r2, [r4, r9, lsl #2]                          <== NOT EXECUTED
   33fa0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33fa4:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   33fa8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   33fac:	eb0001cb 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                                &map->doubly_buffer,  
                                                map->blocks[doubly],  
                                                true);                
          if (rc > 0)                                                 
   33fb0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33fb4:	ca000012 	bgt	34004 <rtems_rfs_block_map_grow+0x2dc>        <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
   33fb8:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   33fbc:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   33fc0:	e0832106 	add	r2, r3, r6, lsl #2                            <== NOT EXECUTED
   33fc4:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   33fc8:	e7d3c106 	ldrb	ip, [r3, r6, lsl #2]                         <== NOT EXECUTED
   33fcc:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   33fd0:	e5d22001 	ldrb	r2, [r2, #1]                                 <== NOT EXECUTED
   33fd4:	e5d63002 	ldrb	r3, [r6, #2]                                 <== NOT EXECUTED
   33fd8:	e181cc0c 	orr	ip, r1, ip, lsl #24                           <== NOT EXECUTED
   33fdc:	e18cc802 	orr	ip, ip, r2, lsl #16                           <== NOT EXECUTED
   33fe0:	e18cc403 	orr	ip, ip, r3, lsl #8                            <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
   33fe4:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
   33fe8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33fec:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   33ff0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
   33ff4:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
   33ff8:	eb0001b8 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                                singly_block, true);  
          if (rc > 0)                                                 
   33ffc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   34000:	da000005 	ble	3401c <rtems_rfs_block_map_grow+0x2f4>        <== NOT EXECUTED
   34004:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
   34008:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3400c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   34010:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
   34014:	eb000c95 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
            return rc;                                                
   34018:	ea00002b 	b	340cc <rtems_rfs_block_map_grow+0x3a4>          <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
   3401c:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
   34020:	e5dd201b 	ldrb	r2, [sp, #27]                                <== NOT EXECUTED
   34024:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   34028:	e7c32107 	strb	r2, [r3, r7, lsl #2]                         <== NOT EXECUTED
   3402c:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
   34030:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
   34034:	e1dd11ba 	ldrh	r1, [sp, #26]                                <== NOT EXECUTED
   34038:	e1a03107 	lsl	r3, r7, #2                                    <== NOT EXECUTED
   3403c:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
   34040:	e5c21001 	strb	r1, [r2, #1]                                 <== NOT EXECUTED
   34044:	e5942040 	ldr	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
   34048:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
   3404c:	e5922020 	ldr	r2, [r2, #32]                                 <== NOT EXECUTED
   34050:	e1a07087 	lsl	r7, r7, #1                                    <== NOT EXECUTED
   34054:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   34058:	e1a01421 	lsr	r1, r1, #8                                    <== NOT EXECUTED
   3405c:	e7c21087 	strb	r1, [r2, r7, lsl #1]                         <== NOT EXECUTED
   34060:	e5942040 	ldr	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
   34064:	e5922020 	ldr	r2, [r2, #32]                                 <== NOT EXECUTED
   34068:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
   3406c:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
   34070:	e5c32003 	strb	r2, [r3, #3]                                 <== NOT EXECUTED
   34074:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   34078:	e5c42038 	strb	r2, [r4, #56]	; 0x38                         <== NOT EXECUTED
    }                                                                 
                                                                      
    map->size.count++;                                                
   3407c:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   34080:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   34084:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
    map->size.offset = 0;                                             
   34088:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   3408c:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
                                                                      
    if (b == 0)                                                       
   34090:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
      *new_block = block;                                             
   34094:	059d3018 	ldreq	r3, [sp, #24]                               <== NOT EXECUTED
   34098:	059d0010 	ldreq	r0, [sp, #16]                               <== NOT EXECUTED
   3409c:	05803000 	streq	r3, [r0]                                    <== NOT EXECUTED
    map->last_data_block = block;                                     
   340a0:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
    map->dirty = true;                                                
   340a4:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    map->size.count++;                                                
    map->size.offset = 0;                                             
                                                                      
    if (b == 0)                                                       
      *new_block = block;                                             
    map->last_data_block = block;                                     
   340a8:	e5843020 	str	r3, [r4, #32]                                 <== NOT EXECUTED
    map->dirty = true;                                                
   340ac:	e5c42000 	strb	r2, [r4]                                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Allocate a block at a time. The buffer handles hold the blocks so adding
   * this way does not thrash the cache with lots of requests.        
   */                                                                 
  for (b = 0; b < blocks; b++)                                        
   340b0:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   340b4:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   340b8:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
   340bc:	3affff2b 	bcc	33d70 <rtems_rfs_block_map_grow+0x48>         <== NOT EXECUTED
   340c0:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   340c4:	ea000000 	b	340cc <rtems_rfs_block_map_grow+0x3a4>          <== NOT EXECUTED
   340c8:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    map->last_data_block = block;                                     
    map->dirty = true;                                                
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   340cc:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   340d0:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
   340d4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00033c10 <rtems_rfs_block_map_indirect_alloc>: rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, rtems_rfs_buffer_handle* buffer, rtems_rfs_block_no* block, bool upping) {
   33c10:	e92d45f1 	push	{r0, r4, r5, r6, r7, r8, sl, lr}             <== NOT EXECUTED
   33c14:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   33c18:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
   33c1c:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  int                  rc;                                            
  /*                                                                  
   * Save the new block locally because upping can have *block pointing to the
   * slots which are cleared when upping.                             
   */                                                                 
  rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
   33c20:	e591101c 	ldr	r1, [r1, #28]                                 <== NOT EXECUTED
   33c24:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   33c28:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system*   fs,      
                                    rtems_rfs_block_map*     map,     
                                    rtems_rfs_buffer_handle* buffer,  
                                    rtems_rfs_block_no*      block,   
                                    bool                     upping)  
{                                                                     
   33c2c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   33c30:	e5dd7020 	ldrb	r7, [sp, #32]                                <== NOT EXECUTED
  int                  rc;                                            
  /*                                                                  
   * Save the new block locally because upping can have *block pointing to the
   * slots which are cleared when upping.                             
   */                                                                 
  rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
   33c34:	eb000daa 	bl	372e4 <rtems_rfs_group_bitmap_alloc>           <== NOT EXECUTED
  if (rc > 0)                                                         
   33c38:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   33c3c:	ca000037 	bgt	33d20 <rtems_rfs_block_map_indirect_alloc+0x110><== NOT EXECUTED
    return rc;                                                        
  rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
   33c40:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   33c44:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33c48:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   33c4c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   33c50:	eb0002a2 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
  if (rc > 0)                                                         
   33c54:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   33c58:	da000004 	ble	33c70 <rtems_rfs_block_map_indirect_alloc+0x60><== NOT EXECUTED
  {                                                                   
    rtems_rfs_group_bitmap_free (fs, false, new_block);               
   33c5c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   33c60:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   33c64:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   33c68:	eb000d80 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
    return rc;                                                        
   33c6c:	ea00002b 	b	33d20 <rtems_rfs_block_map_indirect_alloc+0x110><== NOT EXECUTED
  }                                                                   
  memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
   33c70:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   33c74:	e5962008 	ldr	r2, [r6, #8]                                  <== NOT EXECUTED
   33c78:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   33c7c:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   33c80:	eb0031d5 	bl	403dc <memset>                                 <== NOT EXECUTED
  if (upping)                                                         
   33c84:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   33c88:	0a00001e 	beq	33d08 <rtems_rfs_block_map_indirect_alloc+0xf8><== NOT EXECUTED
   33c8c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   33c90:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    int b;                                                            
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))             
      printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
              map->size.count);                                       
    for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                      
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
   33c94:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   33c98:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
   33c9c:	e5d3c027 	ldrb	ip, [r3, #39]	; 0x27                         <== NOT EXECUTED
   33ca0:	e5900020 	ldr	r0, [r0, #32]                                 <== NOT EXECUTED
   33ca4:	e7c0c002 	strb	ip, [r0, r2]                                 <== NOT EXECUTED
   33ca8:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
   33cac:	e5900020 	ldr	r0, [r0, #32]                                 <== NOT EXECUTED
   33cb0:	e1d3c2b6 	ldrh	ip, [r3, #38]	; 0x26                         <== NOT EXECUTED
   33cb4:	e0800002 	add	r0, r0, r2                                    <== NOT EXECUTED
   33cb8:	e5c0c001 	strb	ip, [r0, #1]                                 <== NOT EXECUTED
   33cbc:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
   33cc0:	e593c024 	ldr	ip, [r3, #36]	; 0x24                          <== NOT EXECUTED
   33cc4:	e5900020 	ldr	r0, [r0, #32]                                 <== NOT EXECUTED
   33cc8:	e1a0c42c 	lsr	ip, ip, #8                                    <== NOT EXECUTED
   33ccc:	e0800002 	add	r0, r0, r2                                    <== NOT EXECUTED
   33cd0:	e5c0c002 	strb	ip, [r0, #2]                                 <== NOT EXECUTED
   33cd4:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
   33cd8:	e5900020 	ldr	r0, [r0, #32]                                 <== NOT EXECUTED
   33cdc:	e593c024 	ldr	ip, [r3, #36]	; 0x24                          <== NOT EXECUTED
   33ce0:	e0800002 	add	r0, r0, r2                                    <== NOT EXECUTED
   33ce4:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
  {                                                                   
    int b;                                                            
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))             
      printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
              map->size.count);                                       
    for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                      
   33ce8:	e3520014 	cmp	r2, #20                                       <== NOT EXECUTED
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
   33cec:	e5c0c003 	strb	ip, [r0, #3]                                 <== NOT EXECUTED
   33cf0:	e2833004 	add	r3, r3, #4                                    <== NOT EXECUTED
   33cf4:	e5c41000 	strb	r1, [r4]                                     <== NOT EXECUTED
  {                                                                   
    int b;                                                            
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))             
      printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
              map->size.count);                                       
    for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                      
   33cf8:	1affffe6 	bne	33c98 <rtems_rfs_block_map_indirect_alloc+0x88><== NOT EXECUTED
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
    memset (map->blocks, 0, sizeof (map->blocks));                    
   33cfc:	e2850024 	add	r0, r5, #36	; 0x24                            <== NOT EXECUTED
   33d00:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   33d04:	eb0031b4 	bl	403dc <memset>                                 <== NOT EXECUTED
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
  *block = new_block;                                                 
   33d08:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
              map->size.count);                                       
    for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                      
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
    memset (map->blocks, 0, sizeof (map->blocks));                    
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
   33d0c:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
  *block = new_block;                                                 
   33d10:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
              map->size.count);                                       
    for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                      
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
    memset (map->blocks, 0, sizeof (map->blocks));                    
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
   33d14:	e5c42000 	strb	r2, [r4]                                     <== NOT EXECUTED
  *block = new_block;                                                 
  map->last_map_block = new_block;                                    
   33d18:	e585301c 	str	r3, [r5, #28]                                 <== NOT EXECUTED
   33d1c:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   33d20:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   33d24:	e8bd85f8 	pop	{r3, r4, r5, r6, r7, r8, sl, pc}              <== NOT EXECUTED
                                                                      

000338a0 <rtems_rfs_block_map_indirect_shrink>: rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, rtems_rfs_buffer_handle* buffer, rtems_rfs_block_no indirect, rtems_rfs_block_no index) {
   338a0:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   338a4:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
   * block to be freed and the indirect block is now also free, or we have only
   * one indirect table and we can fit the remaining blocks into the inode,
   * then either move to the next indirect block or move the remaining blocks
   * into the inode and free the indirect table's block.              
   */                                                                 
  if ((index == 0) ||                                                 
   338a8:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system*   fs,     
                                     rtems_rfs_block_map*     map,    
                                     rtems_rfs_buffer_handle* buffer, 
                                     rtems_rfs_block_no       indirect,
                                     rtems_rfs_block_no       index)  
{                                                                     
   338ac:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   * block to be freed and the indirect block is now also free, or we have only
   * one indirect table and we can fit the remaining blocks into the inode,
   * then either move to the next indirect block or move the remaining blocks
   * into the inode and free the indirect table's block.              
   */                                                                 
  if ((index == 0) ||                                                 
   338b0:	0a000005 	beq	338cc <rtems_rfs_block_map_indirect_shrink+0x2c><== NOT EXECUTED
   338b4:	e35c0005 	cmp	ip, #5                                        <== NOT EXECUTED
   338b8:	03530000 	cmpeq	r3, #0                                      <== NOT EXECUTED
   338bc:	13a01000 	movne	r1, #0                                      <== NOT EXECUTED
   338c0:	03a01001 	moveq	r1, #1                                      <== NOT EXECUTED
   338c4:	11a00001 	movne	r0, r1                                      <== NOT EXECUTED
   338c8:	18bd8070 	popne	{r4, r5, r6, pc}                            <== NOT EXECUTED
      ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))         
  {                                                                   
    rtems_rfs_block_no block_to_free = map->blocks[indirect];         
                                                                      
    if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))         
   338cc:	e35c0005 	cmp	ip, #5                                        <== NOT EXECUTED
   338d0:	03530000 	cmpeq	r3, #0                                      <== NOT EXECUTED
   338d4:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
   338d8:	03a0c001 	moveq	ip, #1                                      <== NOT EXECUTED
   * into the inode and free the indirect table's block.              
   */                                                                 
  if ((index == 0) ||                                                 
      ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))         
  {                                                                   
    rtems_rfs_block_no block_to_free = map->blocks[indirect];         
   338dc:	e2833009 	add	r3, r3, #9                                    <== NOT EXECUTED
   338e0:	e7945103 	ldr	r5, [r4, r3, lsl #2]                          <== NOT EXECUTED
    else                                                              
    {                                                                 
      /*                                                              
       * One less singly indirect block in the inode.                 
       */                                                             
      map->blocks[indirect] = 0;                                      
   338e4:	1784c103 	strne	ip, [r4, r3, lsl #2]                        <== NOT EXECUTED
  if ((index == 0) ||                                                 
      ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))         
  {                                                                   
    rtems_rfs_block_no block_to_free = map->blocks[indirect];         
                                                                      
    if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))         
   338e8:	1a000010 	bne	33930 <rtems_rfs_block_map_indirect_shrink+0x90><== NOT EXECUTED
   338ec:	e5923008 	ldr	r3, [r2, #8]                                  <== NOT EXECUTED
   338f0:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   338f4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
 * @param indirect The index index in the inode's block table.        
 * @param index The index in the indirect table of the block.         
 * @return int The error number (errno). No error if 0.               
 */                                                                   
static int                                                            
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system*   fs,     
   338f8:	e2831014 	add	r1, r3, #20                                   <== NOT EXECUTED
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
        map->blocks[b] = rtems_rfs_block_get_number (buffer, b);      
   338fc:	e5d3c001 	ldrb	ip, [r3, #1]                                 <== NOT EXECUTED
   33900:	e5d3e000 	ldrb	lr, [r3]                                     <== NOT EXECUTED
   33904:	e5d36003 	ldrb	r6, [r3, #3]                                 <== NOT EXECUTED
   33908:	e1a0c80c 	lsl	ip, ip, #16                                   <== NOT EXECUTED
   3390c:	e18ccc0e 	orr	ip, ip, lr, lsl #24                           <== NOT EXECUTED
   33910:	e5d3e002 	ldrb	lr, [r3, #2]                                 <== NOT EXECUTED
   33914:	e18cc006 	orr	ip, ip, r6                                    <== NOT EXECUTED
   33918:	e2833004 	add	r3, r3, #4                                    <== NOT EXECUTED
   3391c:	e18cc40e 	orr	ip, ip, lr, lsl #8                            <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
   33920:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
        map->blocks[b] = rtems_rfs_block_get_number (buffer, b);      
   33924:	e582c024 	str	ip, [r2, #36]	; 0x24                          <== NOT EXECUTED
   33928:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
   3392c:	1afffff2 	bne	338fc <rtems_rfs_block_map_indirect_shrink+0x5c><== NOT EXECUTED
       * One less singly indirect block in the inode.                 
       */                                                             
      map->blocks[indirect] = 0;                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
   33930:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   33934:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   33938:	eb000e4c 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
    if (rc > 0)                                                       
   3393c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      return rc;                                                      
                                                                      
    map->last_map_block = block_to_free;                              
   33940:	d584501c 	strle	r5, [r4, #28]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   33944:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

0003380c <rtems_rfs_block_map_next_block>: int rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, rtems_rfs_block_no* block) {
   3380c:	e92d4007 	push	{r0, r1, r2, lr}                             <== NOT EXECUTED
  rtems_rfs_block_pos bpos;                                           
  bpos.bno = map->bpos.bno + 1;                                       
   33810:	e591e010 	ldr	lr, [r1, #16]                                 <== NOT EXECUTED
  bpos.boff = 0;                                                      
   33814:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs,            
                                rtems_rfs_block_map*   map,           
                                rtems_rfs_block_no*    block)         
{                                                                     
   33818:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
  rtems_rfs_block_pos bpos;                                           
  bpos.bno = map->bpos.bno + 1;                                       
   3381c:	e28ee001 	add	lr, lr, #1                                    <== NOT EXECUTED
  bpos.boff = 0;                                                      
  bpos.block = 0;                                                     
  return rtems_rfs_block_map_find (fs, map, &bpos, block);            
   33820:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs,            
                                rtems_rfs_block_map*   map,           
                                rtems_rfs_block_no*    block)         
{                                                                     
  rtems_rfs_block_pos bpos;                                           
  bpos.bno = map->bpos.bno + 1;                                       
   33824:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
  bpos.boff = 0;                                                      
  bpos.block = 0;                                                     
   33828:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
                                rtems_rfs_block_map*   map,           
                                rtems_rfs_block_no*    block)         
{                                                                     
  rtems_rfs_block_pos bpos;                                           
  bpos.bno = map->bpos.bno + 1;                                       
  bpos.boff = 0;                                                      
   3382c:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
  bpos.block = 0;                                                     
  return rtems_rfs_block_map_find (fs, map, &bpos, block);            
   33830:	ebffff9f 	bl	336b4 <rtems_rfs_block_map_find>               <== NOT EXECUTED
}                                                                     
   33834:	e8bd800e 	pop	{r1, r2, r3, pc}                              <== NOT EXECUTED
                                                                      

000342a0 <rtems_rfs_block_map_open>: int rtems_rfs_block_map_open (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* inode, rtems_rfs_block_map* map) {
   342a0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
   * Set the count to 0 so at least find fails, then open the handle and make
   * sure the inode has been loaded into memory. If we did not load the inode
   * do not unload it. The caller may assume it is still loaded when we return.
   */                                                                 
                                                                      
  map->dirty = false;                                                 
   342a4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   342a8:	e5c25000 	strb	r5, [r2]                                     <== NOT EXECUTED
  map->inode = NULL;                                                  
   342ac:	e5825004 	str	r5, [r2, #4]                                  <== NOT EXECUTED
 * @param size A pointer to the block size.                           
 */                                                                   
static inline void                                                    
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)            
{                                                                     
  size->count = 0;                                                    
   342b0:	e5825008 	str	r5, [r2, #8]                                  <== NOT EXECUTED
  size->offset = 0;                                                   
   342b4:	e582500c 	str	r5, [r2, #12]                                 <== NOT EXECUTED
 * @param bpos A pointer to the block position.                       
 */                                                                   
static inline void                                                    
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)             
{                                                                     
  bpos->bno = 0;                                                      
   342b8:	e5825010 	str	r5, [r2, #16]                                 <== NOT EXECUTED
  bpos->boff = 0;                                                     
   342bc:	e5825014 	str	r5, [r2, #20]                                 <== NOT EXECUTED
  bpos->block = 0;                                                    
   342c0:	e5825018 	str	r5, [r2, #24]                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   342c4:	e5c25038 	strb	r5, [r2, #56]	; 0x38                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   342c8:	e582503c 	str	r5, [r2, #60]	; 0x3c                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   342cc:	e5825040 	str	r5, [r2, #64]	; 0x40                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   342d0:	e5c25044 	strb	r5, [r2, #68]	; 0x44                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   342d4:	e5825048 	str	r5, [r2, #72]	; 0x48                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   342d8:	e582504c 	str	r5, [r2, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,                 
                          rtems_rfs_inode_handle* inode,              
                          rtems_rfs_block_map*    map)                
{                                                                     
   342dc:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
   342e0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   342e4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
    return rc;                                                        
  rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);        
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_load (fs, inode);                              
   342e8:	eb000d8f 	bl	3792c <rtems_rfs_inode_load>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   342ec:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   342f0:	da00000d 	ble	3432c <rtems_rfs_block_map_open+0x8c>         <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   342f4:	e2841038 	add	r1, r4, #56	; 0x38                            <== NOT EXECUTED
   342f8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   342fc:	eb0000ae 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   34300:	e5c45038 	strb	r5, [r4, #56]	; 0x38                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34304:	e584503c 	str	r5, [r4, #60]	; 0x3c                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   34308:	e5845040 	str	r5, [r4, #64]	; 0x40                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   3430c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   34310:	e2841044 	add	r1, r4, #68	; 0x44                            <== NOT EXECUTED
   34314:	eb0000a8 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   34318:	e584504c 	str	r5, [r4, #76]	; 0x4c                          <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   3431c:	e5c45044 	strb	r5, [r4, #68]	; 0x44                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34320:	e5845048 	str	r5, [r4, #72]	; 0x48                          <== NOT EXECUTED
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
                                                                      
  return rc;                                                          
}                                                                     
   34324:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   34328:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Extract the block and block count data from the inode into the targets
   * byte order.                                                      
   */                                                                 
  map->inode = inode;                                                 
   3432c:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   34330:	e5846004 	str	r6, [r4, #4]                                  <== NOT EXECUTED
  block_size = rtems_rfs_fs_block_size (fs);                          
  return (((uint64_t) (size->count - 1)) * block_size) + offset;      
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,                 
   34334:	e2831030 	add	r1, r3, #48	; 0x30                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Extract the block and block count data from the inode into the targets
   * byte order.                                                      
   */                                                                 
  map->inode = inode;                                                 
   34338:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   3433c:	e283301c 	add	r3, r3, #28                                   <== NOT EXECUTED
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
   34340:	e5d30001 	ldrb	r0, [r3, #1]                                 <== NOT EXECUTED
   34344:	e5d3c000 	ldrb	ip, [r3]                                     <== NOT EXECUTED
   34348:	e5d35003 	ldrb	r5, [r3, #3]                                 <== NOT EXECUTED
   3434c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
   34350:	e1800c0c 	orr	r0, r0, ip, lsl #24                           <== NOT EXECUTED
   34354:	e5d3c002 	ldrb	ip, [r3, #2]                                 <== NOT EXECUTED
   34358:	e1800005 	orr	r0, r0, r5                                    <== NOT EXECUTED
   3435c:	e2833004 	add	r3, r3, #4                                    <== NOT EXECUTED
   34360:	e180040c 	orr	r0, r0, ip, lsl #8                            <== NOT EXECUTED
  /*                                                                  
   * Extract the block and block count data from the inode into the targets
   * byte order.                                                      
   */                                                                 
  map->inode = inode;                                                 
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
   34364:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
   34368:	e5820024 	str	r0, [r2, #36]	; 0x24                          <== NOT EXECUTED
   3436c:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
  /*                                                                  
   * Extract the block and block count data from the inode into the targets
   * byte order.                                                      
   */                                                                 
  map->inode = inode;                                                 
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
   34370:	1afffff2 	bne	34340 <rtems_rfs_block_map_open+0xa0>         <== NOT EXECUTED
 * @return uint32_t The block count.                                  
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)      
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->block_count);             
   34374:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
   34378:	e283200c 	add	r2, r3, #12                                   <== NOT EXECUTED
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
  map->size.count = rtems_rfs_inode_get_block_count (inode);          
   3437c:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   34380:	e5d3000c 	ldrb	r0, [r3, #12]                                <== NOT EXECUTED
   34384:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
   34388:	e1810c00 	orr	r0, r1, r0, lsl #24                           <== NOT EXECUTED
   3438c:	e5d21002 	ldrb	r1, [r2, #2]                                 <== NOT EXECUTED
   34390:	e180280c 	orr	r2, r0, ip, lsl #16                           <== NOT EXECUTED
   34394:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   34398:	e5842008 	str	r2, [r4, #8]                                  <== NOT EXECUTED
  map->size.offset = rtems_rfs_inode_get_block_offset (inode);        
   3439c:	e5d3100a 	ldrb	r1, [r3, #10]                                <== NOT EXECUTED
   343a0:	e5d3200b 	ldrb	r2, [r3, #11]                                <== NOT EXECUTED
   343a4:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   343a8:	e584200c 	str	r2, [r4, #12]                                 <== NOT EXECUTED
 * @return uint32_t The last map block number.                        
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)   
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->last_map_block);          
   343ac:	e2832030 	add	r2, r3, #48	; 0x30                            <== NOT EXECUTED
  map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);   
   343b0:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   343b4:	e5d30030 	ldrb	r0, [r3, #48]	; 0x30                         <== NOT EXECUTED
   343b8:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
   343bc:	e1810c00 	orr	r0, r1, r0, lsl #24                           <== NOT EXECUTED
   343c0:	e5d21002 	ldrb	r1, [r2, #2]                                 <== NOT EXECUTED
   343c4:	e180280c 	orr	r2, r0, ip, lsl #16                           <== NOT EXECUTED
   343c8:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   343cc:	e584201c 	str	r2, [r4, #28]                                 <== NOT EXECUTED
 * @return uint32_t The last data block number.                       
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)  
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->last_data_block);         
   343d0:	e2832034 	add	r2, r3, #52	; 0x34                            <== NOT EXECUTED
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
   343d4:	e5d30034 	ldrb	r0, [r3, #52]	; 0x34                         <== NOT EXECUTED
   343d8:	e5d23003 	ldrb	r3, [r2, #3]                                 <== NOT EXECUTED
   343dc:	e5d21001 	ldrb	r1, [r2, #1]                                 <== NOT EXECUTED
   343e0:	e1833c00 	orr	r3, r3, r0, lsl #24                           <== NOT EXECUTED
   343e4:	e5d22002 	ldrb	r2, [r2, #2]                                 <== NOT EXECUTED
   343e8:	e1833801 	orr	r3, r3, r1, lsl #16                           <== NOT EXECUTED
   343ec:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
   343f0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   343f4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   343f8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
  map->size.count = rtems_rfs_inode_get_block_count (inode);          
  map->size.offset = rtems_rfs_inode_get_block_offset (inode);        
  map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);   
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
   343fc:	e5843020 	str	r3, [r4, #32]                                 <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
                                                                      
  return rc;                                                          
}                                                                     
   34400:	e8bd41f0 	pop	{r4, r5, r6, r7, r8, lr}                      <== NOT EXECUTED
  map->size.count = rtems_rfs_inode_get_block_count (inode);          
  map->size.offset = rtems_rfs_inode_get_block_offset (inode);        
  map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);   
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
   34404:	ea000d11 	b	37850 <rtems_rfs_inode_unload>                  <== NOT EXECUTED
                                                                      

00033838 <rtems_rfs_block_map_seek>: int rtems_rfs_block_map_seek (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, rtems_rfs_pos_rel offset, rtems_rfs_block_no* block) {
   33838:	e92d43f7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, lr}     <== NOT EXECUTED
  rtems_rfs_block_pos bpos;                                           
  rtems_rfs_block_copy_bpos (&bpos, &map->bpos);                      
   3383c:	e591c014 	ldr	ip, [r1, #20]                                 <== NOT EXECUTED
static inline void                                                    
rtems_rfs_block_add_pos (rtems_rfs_file_system*  fs,                  
                         rtems_rfs_pos_rel       offset,              
                         rtems_rfs_block_pos*    bpos)                
{                                                                     
  rtems_rfs_block_get_bpos (fs,                                       
   33840:	e5905008 	ldr	r5, [r0, #8]                                  <== NOT EXECUTED
   33844:	e591e010 	ldr	lr, [r1, #16]                                 <== NOT EXECUTED
int                                                                   
rtems_rfs_block_map_seek (rtems_rfs_file_system* fs,                  
                          rtems_rfs_block_map*   map,                 
                          rtems_rfs_pos_rel      offset,              
                          rtems_rfs_block_no*    block)               
{                                                                     
   33848:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   3384c:	e021ce95 	mla	r1, r5, lr, ip                                <== NOT EXECUTED
   33850:	e0928001 	adds	r8, r2, r1                                   <== NOT EXECUTED
   33854:	e2a39000 	adc	r9, r3, #0                                    <== NOT EXECUTED
  rtems_rfs_block_pos bpos;                                           
  rtems_rfs_block_copy_bpos (&bpos, &map->bpos);                      
   33858:	e5947018 	ldr	r7, [r4, #24]                                 <== NOT EXECUTED
int                                                                   
rtems_rfs_block_map_seek (rtems_rfs_file_system* fs,                  
                          rtems_rfs_block_map*   map,                 
                          rtems_rfs_pos_rel      offset,              
                          rtems_rfs_block_no*    block)               
{                                                                     
   3385c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   33860:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   33864:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   33868:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
  rtems_rfs_block_pos bpos;                                           
  rtems_rfs_block_copy_bpos (&bpos, &map->bpos);                      
   3386c:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   33870:	e58d7008 	str	r7, [sp, #8]                                  <== NOT EXECUTED
   33874:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
   33878:	ebffff30 	bl	33540 <rtems_rfs_block_get_bpos>               <== NOT EXECUTED
                            rtems_rfs_block_get_pos (fs, bpos) + offset,
                            bpos);                                    
  bpos->block = 0;                                                    
   3387c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
  rtems_rfs_block_add_pos (fs, offset, &bpos);                        
  return rtems_rfs_block_map_find (fs, map, &bpos, block);            
   33880:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   33884:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33888:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   3388c:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
static inline void                                                    
rtems_rfs_block_add_pos (rtems_rfs_file_system*  fs,                  
                         rtems_rfs_pos_rel       offset,              
                         rtems_rfs_block_pos*    bpos)                
{                                                                     
  rtems_rfs_block_get_bpos (fs,                                       
   33890:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
                            rtems_rfs_block_get_pos (fs, bpos) + offset,
                            bpos);                                    
  bpos->block = 0;                                                    
   33894:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   33898:	ebffff85 	bl	336b4 <rtems_rfs_block_map_find>               <== NOT EXECUTED
}                                                                     
   3389c:	e8bd83fe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, pc}      <== NOT EXECUTED
                                                                      

00033948 <rtems_rfs_block_map_shrink>: { if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK)) printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n", blocks, map->size.count); if (map->size.count == 0)
   33948:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
   3394c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,                
                            rtems_rfs_block_map*   map,               
                            size_t                 blocks)            
{                                                                     
   33950:	e92d4ff7 	push	{r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
   33954:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   33958:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))             
    printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
            blocks, map->size.count);                                 
                                                                      
  if (map->size.count == 0)                                           
   3395c:	0a0000a7 	beq	33c00 <rtems_rfs_block_map_shrink+0x2b8>      <== NOT EXECUTED
   33960:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   33964:	31a09002 	movcc	r9, r2                                      <== NOT EXECUTED
   33968:	21a09003 	movcs	r9, r3                                      <== NOT EXECUTED
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
        doubly_singly = singly % fs->blocks_per_block;                
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   3396c:	e2812044 	add	r2, r1, #68	; 0x44                            <== NOT EXECUTED
      {                                                               
        /*                                                            
         * Request the indirect block and then obtain the block number from the
         * indirect block.                                            
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
   33970:	e281b038 	add	fp, r1, #56	; 0x38                            <== NOT EXECUTED
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
        doubly_singly = singly % fs->blocks_per_block;                
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   33974:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
   33978:	ea000080 	b	33b80 <rtems_rfs_block_map_shrink+0x238>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_block_no block;                                         
    rtems_rfs_block_no block_to_free;                                 
    int                rc;                                            
                                                                      
    block = map->size.count - 1;                                      
   3397c:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   33980:	e243a001 	sub	sl, r3, #1                                    <== NOT EXECUTED
                                                                      
    if (block < RTEMS_RFS_INODE_BLOCKS)                               
   33984:	e35a0004 	cmp	sl, #4                                        <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
       * inode.                                                       
       */                                                             
      block_to_free = map->blocks[block];                             
   33988:	92833008 	addls	r3, r3, #8                                  <== NOT EXECUTED
      map->blocks[block] = 0;                                         
   3398c:	93a02000 	movls	r2, #0                                      <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
       * inode.                                                       
       */                                                             
      block_to_free = map->blocks[block];                             
   33990:	97948103 	ldrls	r8, [r4, r3, lsl #2]                        <== NOT EXECUTED
      map->blocks[block] = 0;                                         
   33994:	97842103 	strls	r2, [r4, r3, lsl #2]                        <== NOT EXECUTED
   33998:	9a000069 	bls	33b44 <rtems_rfs_block_map_shrink+0x1fc>      <== NOT EXECUTED
       * table of block numbers.                                      
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
   3399c:	e5957030 	ldr	r7, [r5, #48]	; 0x30                          <== NOT EXECUTED
   339a0:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   339a4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   339a8:	eb0085a6 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
      singly = block / fs->blocks_per_block;                          
   339ac:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
       * table of block numbers.                                      
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
   339b0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
      singly = block / fs->blocks_per_block;                          
   339b4:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   339b8:	eb00850e 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
      if (block < fs->block_map_singly_blocks)                        
   339bc:	e5953034 	ldr	r3, [r5, #52]	; 0x34                          <== NOT EXECUTED
   339c0:	e15a0003 	cmp	sl, r3                                        <== NOT EXECUTED
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
      singly = block / fs->blocks_per_block;                          
   339c4:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
                                                                      
      if (block < fs->block_map_singly_blocks)                        
   339c8:	2a00001d 	bcs	33a44 <rtems_rfs_block_map_shrink+0xfc>       <== NOT EXECUTED
      {                                                               
        /*                                                            
         * Request the indirect block and then obtain the block number from the
         * indirect block.                                            
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
   339cc:	e2803009 	add	r3, r0, #9                                    <== NOT EXECUTED
   339d0:	e7942103 	ldr	r2, [r4, r3, lsl #2]                          <== NOT EXECUTED
   339d4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   339d8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   339dc:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   339e0:	eb00033e 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                              map->blocks[singly], true);
        if (rc > 0)                                                   
   339e4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   339e8:	ca000085 	bgt	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
   339ec:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
   339f0:	e593c020 	ldr	ip, [r3, #32]                                 <== NOT EXECUTED
   339f4:	e08c7106 	add	r7, ip, r6, lsl #2                            <== NOT EXECUTED
   339f8:	e1a0e007 	mov	lr, r7                                        <== NOT EXECUTED
   339fc:	e5d77002 	ldrb	r7, [r7, #2]                                 <== NOT EXECUTED
   33a00:	e58d7004 	str	r7, [sp, #4]                                  <== NOT EXECUTED
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
   33a04:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   33a08:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33a0c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33a10:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                              map->blocks[singly], true);
        if (rc > 0)                                                   
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
   33a14:	e5dea003 	ldrb	sl, [lr, #3]                                 <== NOT EXECUTED
   33a18:	e7dc8106 	ldrb	r8, [ip, r6, lsl #2]                         <== NOT EXECUTED
   33a1c:	e5de7001 	ldrb	r7, [lr, #1]                                 <== NOT EXECUTED
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
   33a20:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
   33a24:	ebffff9d 	bl	338a0 <rtems_rfs_block_map_indirect_shrink>    <== NOT EXECUTED
                                                  singly, direct);    
        if (rc)                                                       
   33a28:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33a2c:	1a000074 	bne	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                              map->blocks[singly], true);
        if (rc > 0)                                                   
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
   33a30:	e18a8c08 	orr	r8, sl, r8, lsl #24                           <== NOT EXECUTED
   33a34:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   33a38:	e1888807 	orr	r8, r8, r7, lsl #16                           <== NOT EXECUTED
   33a3c:	e1888403 	orr	r8, r8, r3, lsl #8                            <== NOT EXECUTED
   33a40:	ea00003f 	b	33b44 <rtems_rfs_block_map_shrink+0x1fc>        <== NOT EXECUTED
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
                                                  singly, direct);    
        if (rc)                                                       
          return rc;                                                  
      }                                                               
      else if (block < fs->block_map_doubly_blocks)                   
   33a44:	e5953038 	ldr	r3, [r5, #56]	; 0x38                          <== NOT EXECUTED
   33a48:	e15a0003 	cmp	sl, r3                                        <== NOT EXECUTED
   33a4c:	2a00004d 	bcs	33b88 <rtems_rfs_block_map_shrink+0x240>      <== NOT EXECUTED
         * value is still valid for doubly indirect tables.           
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
   33a50:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   33a54:	eb0084e7 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   33a58:	e2803009 	add	r3, r0, #9                                    <== NOT EXECUTED
         * value is still valid for doubly indirect tables.           
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
   33a5c:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
   33a60:	e7942103 	ldr	r2, [r4, r3, lsl #2]                          <== NOT EXECUTED
   33a64:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33a68:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
   33a6c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   33a70:	eb00031a 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                              map->blocks[doubly], true);
        if (rc > 0)                                                   
   33a74:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33a78:	ca000061 	bgt	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
        doubly_singly = singly % fs->blocks_per_block;                
   33a7c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   33a80:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   33a84:	eb00856f 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
                                              map->blocks[doubly], true);
        if (rc > 0)                                                   
          return rc;                                                  
                                                                      
        singly = rtems_rfs_block_get_number (&map->doubly_buffer,     
   33a88:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   33a8c:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   33a90:	e0832100 	add	r2, r3, r0, lsl #2                            <== NOT EXECUTED
   33a94:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   33a98:	e7d3a100 	ldrb	sl, [r3, r0, lsl #2]                         <== NOT EXECUTED
   33a9c:	e5d22001 	ldrb	r2, [r2, #1]                                 <== NOT EXECUTED
   33aa0:	e0833100 	add	r3, r3, r0, lsl #2                            <== NOT EXECUTED
   33aa4:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   33aa8:	e181ac0a 	orr	sl, r1, sl, lsl #24                           <== NOT EXECUTED
   33aac:	e18aa802 	orr	sl, sl, r2, lsl #16                           <== NOT EXECUTED
   33ab0:	e18aa403 	orr	sl, sl, r3, lsl #8                            <== NOT EXECUTED
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
        doubly_singly = singly % fs->blocks_per_block;                
   33ab4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
   33ab8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   33abc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33ac0:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   33ac4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   33ac8:	eb000304 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                              singly, true);          
        if (rc > 0)                                                   
   33acc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33ad0:	ca00004b 	bgt	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
   33ad4:	e5943040 	ldr	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
   33ad8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
   33adc:	e0832106 	add	r2, r3, r6, lsl #2                            <== NOT EXECUTED
   33ae0:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   33ae4:	e7d38106 	ldrb	r8, [r3, r6, lsl #2]                         <== NOT EXECUTED
   33ae8:	e5d22001 	ldrb	r2, [r2, #1]                                 <== NOT EXECUTED
   33aec:	e0833106 	add	r3, r3, r6, lsl #2                            <== NOT EXECUTED
   33af0:	e1818c08 	orr	r8, r1, r8, lsl #24                           <== NOT EXECUTED
   33af4:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   33af8:	e1888802 	orr	r8, r8, r2, lsl #16                           <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
   33afc:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                              singly, true);          
        if (rc > 0)                                                   
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
   33b00:	e1888403 	orr	r8, r8, r3, lsl #8                            <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
   33b04:	1a00000e 	bne	33b44 <rtems_rfs_block_map_shrink+0x1fc>      <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_group_bitmap_free (fs, false, singly);       
   33b08:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   33b0c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33b10:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   33b14:	eb000dd5 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
          if (rc > 0)                                                 
   33b18:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33b1c:	ca000038 	bgt	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
            return rc;                                                
                                                                      
          map->last_map_block = singly;                               
   33b20:	e584a01c 	str	sl, [r4, #28]                                 <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
   33b24:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   33b28:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33b2c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   33b30:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   33b34:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
   33b38:	ebffff58 	bl	338a0 <rtems_rfs_block_map_indirect_shrink>    <== NOT EXECUTED
                                                    doubly, doubly_singly);
          if (rc)                                                     
   33b3c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33b40:	1a00002f 	bne	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
      {                                                               
        rc = EIO;                                                     
        break;                                                        
      }                                                               
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
   33b44:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   33b48:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   33b4c:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   33b50:	eb000dc6 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
    if (rc > 0)                                                       
   33b54:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   33b58:	ca000029 	bgt	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
      return rc;                                                      
    map->size.count--;                                                
   33b5c:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   33b60:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   33b64:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
    map->size.offset = 0;                                             
   33b68:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
   33b6c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
    if (rc > 0)                                                       
      return rc;                                                      
    map->size.count--;                                                
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
   33b70:	e5848020 	str	r8, [r4, #32]                                 <== NOT EXECUTED
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
    if (rc > 0)                                                       
      return rc;                                                      
    map->size.count--;                                                
    map->size.offset = 0;                                             
   33b74:	e584200c 	str	r2, [r4, #12]                                 <== NOT EXECUTED
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
   33b78:	e5c43000 	strb	r3, [r4]                                     <== NOT EXECUTED
    blocks--;                                                         
   33b7c:	e2499001 	sub	r9, r9, #1                                    <== NOT EXECUTED
    return 0;                                                         
                                                                      
  if (blocks > map->size.count)                                       
    blocks = map->size.count;                                         
                                                                      
  while (blocks)                                                      
   33b80:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   33b84:	1affff7c 	bne	3397c <rtems_rfs_block_map_shrink+0x34>       <== NOT EXECUTED
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
    blocks--;                                                         
  }                                                                   
                                                                      
  if (map->size.count == 0)                                           
   33b88:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   33b8c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  {                                                                   
    map->last_map_block = 0;                                          
    map->last_data_block = 0;                                         
   33b90:	05843020 	streq	r3, [r4, #32]                               <== NOT EXECUTED
    blocks--;                                                         
  }                                                                   
                                                                      
  if (map->size.count == 0)                                           
  {                                                                   
    map->last_map_block = 0;                                          
   33b94:	0584301c 	streq	r3, [r4, #28]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Keep the position inside the map.                                
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
   33b98:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
   33b9c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   33ba0:	0a000002 	beq	33bb0 <rtems_rfs_block_map_shrink+0x268>      <== NOT EXECUTED
   33ba4:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
   33ba8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   33bac:	0a000009 	beq	33bd8 <rtems_rfs_block_map_shrink+0x290>      <== NOT EXECUTED
   33bb0:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
   33bb4:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   33bb8:	2a000006 	bcs	33bd8 <rtems_rfs_block_map_shrink+0x290>      <== NOT EXECUTED
   33bbc:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   33bc0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   33bc4:	1a00000d 	bne	33c00 <rtems_rfs_block_map_shrink+0x2b8>      <== NOT EXECUTED
   33bc8:	e5942014 	ldr	r2, [r4, #20]                                 <== NOT EXECUTED
   33bcc:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   33bd0:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   33bd4:	9a000009 	bls	33c00 <rtems_rfs_block_map_shrink+0x2b8>      <== NOT EXECUTED
    rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);           
   33bd8:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
   33bdc:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   33be0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   33be4:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
   33be8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   33bec:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
   33bf0:	e5842014 	str	r2, [r4, #20]                                 <== NOT EXECUTED
   33bf4:	e5840018 	str	r0, [r4, #24]                                 <== NOT EXECUTED
   33bf8:	15843010 	strne	r3, [r4, #16]                               <== NOT EXECUTED
   33bfc:	1a000000 	bne	33c04 <rtems_rfs_block_map_shrink+0x2bc>      <== NOT EXECUTED
   33c00:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   33c04:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
                                                                      

0003c95c <rtems_rfs_buffer_bdbuf_release>: if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", ((intptr_t) buffer->user), buffer->block, modified ? "(modified)" : ""); if (modified)
   3c95c:	e31100ff 	tst	r1, #255	; 0xff                               <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
   3c960:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
    printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
            ((intptr_t) buffer->user),                                
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
   3c964:	0a000001 	beq	3c970 <rtems_rfs_buffer_bdbuf_release+0x14>   <== NOT EXECUTED
    sc = rtems_bdbuf_release_modified (buffer);                       
   3c968:	ebff1dfc 	bl	4160 <rtems_bdbuf_release_modified>            <== NOT EXECUTED
   3c96c:	ea000000 	b	3c974 <rtems_rfs_buffer_bdbuf_release+0x18>     <== NOT EXECUTED
  else                                                                
    sc = rtems_bdbuf_release (buffer);                                
   3c970:	ebff1e1c 	bl	41e8 <rtems_bdbuf_release>                     <== NOT EXECUTED
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   3c974:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c978:	13a00005 	movne	r0, #5                                      <== NOT EXECUTED
   3c97c:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   3c980:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

0003c984 <rtems_rfs_buffer_bdbuf_request>: rtems_rfs_buffer** buffer) { rtems_status_code sc; int rc = 0; if (read)
   3c984:	e31200ff 	tst	r2, #255	; 0xff                               <== NOT EXECUTED
int                                                                   
rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system*   fs,          
                                rtems_rfs_buffer_block   block,       
                                bool                     read,        
                                rtems_rfs_buffer**       buffer)      
{                                                                     
   3c988:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
   3c98c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   3c990:	e590100c 	ldr	r1, [r0, #12]                                 <== NOT EXECUTED
  rtems_status_code sc;                                               
  int               rc = 0;                                           
                                                                      
  if (read)                                                           
   3c994:	0a000002 	beq	3c9a4 <rtems_rfs_buffer_bdbuf_request+0x20>   <== NOT EXECUTED
    sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);  
   3c998:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   3c99c:	ebff2251 	bl	52e8 <rtems_bdbuf_read>                        <== NOT EXECUTED
   3c9a0:	ea000001 	b	3c9ac <rtems_rfs_buffer_bdbuf_request+0x28>     <== NOT EXECUTED
  else                                                                
    sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);   
   3c9a4:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   3c9a8:	ebff221b 	bl	521c <rtems_bdbuf_get>                         <== NOT EXECUTED
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   3c9ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3c9b0:	13a00005 	movne	r0, #5                                      <== NOT EXECUTED
   3c9b4:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   3c9b8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

0003453c <rtems_rfs_buffer_close>: /* * Change the block size to the media device size. It will release and sync * all buffers. */ rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
   3453c:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)                    
{                                                                     
   34540:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Change the block size to the media device size. It will release and sync
   * all buffers.                                                     
   */                                                                 
  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
   34544:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)                    
{                                                                     
   34548:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Change the block size to the media device size. It will release and sync
   * all buffers.                                                     
   */                                                                 
  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
   3454c:	ebffffe7 	bl	344f0 <rtems_rfs_buffer_setblksize>            <== NOT EXECUTED
   34550:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))     
    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rtems_disk_release (fs->disk);                                      
   34554:	e594000c 	ldr	r0, [r4, #12]                                 <== NOT EXECUTED
   34558:	ebff47cb 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
              rc, strerror (rc));                                     
  }                                                                   
#endif                                                                
                                                                      
  return rc;                                                          
}                                                                     
   3455c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34560:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

000348e8 <rtems_rfs_buffer_handle_close>: * @return int The error number (errno). No error if 0. */ static inline int rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle) {
   348e8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   348ec:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  rtems_rfs_buffer_handle_release (fs, handle);                       
   348f0:	ebffff31 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   348f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   348f8:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   348fc:	e5c40000 	strb	r0, [r4]                                     <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34900:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
  handle->buffer = NULL;                                              
  return 0;                                                           
}                                                                     
   34904:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

000345bc <rtems_rfs_buffer_handle_release>: } int rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle) {
   345bc:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
   345c0:	e5916008 	ldr	r6, [r1, #8]                                  <== NOT EXECUTED
   345c4:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,         
                                 rtems_rfs_buffer_handle* handle)     
{                                                                     
   345c8:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   345cc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
   345d0:	0a000040 	beq	346d8 <rtems_rfs_buffer_handle_release+0x11c> <== NOT EXECUTED
              rtems_rfs_buffer_bnum (handle),                         
              rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",       
              rtems_rfs_buffer_refs (handle),                         
              rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
                                                                      
    if (rtems_rfs_buffer_refs (handle) > 0)                           
   345d4:	e5963034 	ldr	r3, [r6, #52]	; 0x34                          <== NOT EXECUTED
   345d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      rtems_rfs_buffer_refs_down (handle);                            
   345dc:	c2433001 	subgt	r3, r3, #1                                  <== NOT EXECUTED
   345e0:	c5863034 	strgt	r3, [r6, #52]	; 0x34                        <== NOT EXECUTED
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
   345e4:	e5967034 	ldr	r7, [r6, #52]	; 0x34                          <== NOT EXECUTED
   345e8:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   345ec:	13a06000 	movne	r6, #0                                      <== NOT EXECUTED
   345f0:	1a000036 	bne	346d0 <rtems_rfs_buffer_handle_release+0x114> <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
   345f4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   345f8:	ebff5f90 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
   345fc:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
   34600:	e5946000 	ldr	r6, [r4]                                      <== NOT EXECUTED
      rtems_rfs_buffer_refs_down (handle);                            
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
   34604:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
   34608:	e2166002 	ands	r6, r6, #2                                   <== NOT EXECUTED
      rtems_rfs_buffer_refs_down (handle);                            
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
   3460c:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
   34610:	0a000005 	beq	3462c <rtems_rfs_buffer_handle_release+0x70>  <== NOT EXECUTED
      {                                                               
        handle->buffer->user = (void*) 0;                             
   34614:	e5950008 	ldr	r0, [r5, #8]                                  <== NOT EXECUTED
        rc = rtems_rfs_buffer_io_release (handle->buffer,             
   34618:	e5d51000 	ldrb	r1, [r5]                                     <== NOT EXECUTED
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
      {                                                               
        handle->buffer->user = (void*) 0;                             
   3461c:	e5807038 	str	r7, [r0, #56]	; 0x38                          <== NOT EXECUTED
        rc = rtems_rfs_buffer_io_release (handle->buffer,             
   34620:	eb0020cd 	bl	3c95c <rtems_rfs_buffer_bdbuf_release>         <== NOT EXECUTED
   34624:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   34628:	ea000028 	b	346d0 <rtems_rfs_buffer_handle_release+0x114>   <== NOT EXECUTED
         * head.                                                      
         *                                                            
         * This code stops a large series of transactions causing all the
         * buffers in the cache being held in queues of this file system.
         */                                                           
        if ((fs->release_count +                                      
   3462c:	e594205c 	ldr	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   34630:	e594306c 	ldr	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
             fs->release_modified_count) >= fs->max_held_buffers)     
   34634:	e594103c 	ldr	r1, [r4, #60]	; 0x3c                          <== NOT EXECUTED
         * head.                                                      
         *                                                            
         * This code stops a large series of transactions causing all the
         * buffers in the cache being held in queues of this file system.
         */                                                           
        if ((fs->release_count +                                      
   34638:	e0830002 	add	r0, r3, r2                                    <== NOT EXECUTED
             fs->release_modified_count) >= fs->max_held_buffers)     
   3463c:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
   34640:	3a000012 	bcc	34690 <rtems_rfs_buffer_handle_release+0xd4>  <== NOT EXECUTED
                                                                      
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
            printf ("rtems-rfs: buffer-release: local cache overflow:"
                    " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
                                                                      
          if (fs->release_count > fs->release_modified_count)         
   34644:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   34648:	9a000006 	bls	34668 <rtems_rfs_buffer_handle_release+0xac>  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
   3464c:	e2840050 	add	r0, r4, #80	; 0x50                            <== NOT EXECUTED
   34650:	ebff5f83 	bl	c464 <_Chain_Get>                              <== NOT EXECUTED
          {                                                           
            buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
            fs->release_count--;                                      
   34654:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   34658:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   3465c:	e584305c 	str	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   34660:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   34664:	ea000005 	b	34680 <rtems_rfs_buffer_handle_release+0xc4>    <== NOT EXECUTED
   34668:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
   3466c:	ebff5f7c 	bl	c464 <_Chain_Get>                              <== NOT EXECUTED
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
   34670:	e594306c 	ldr	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   34674:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   34678:	e584306c 	str	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   3467c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
            modified = true;                                          
          }                                                           
          buffer->user = (void*) 0;                                   
   34680:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   34684:	e5803038 	str	r3, [r0, #56]	; 0x38                          <== NOT EXECUTED
          rc = rtems_rfs_buffer_io_release (buffer, modified);        
   34688:	eb0020b3 	bl	3c95c <rtems_rfs_buffer_bdbuf_release>         <== NOT EXECUTED
   3468c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
        }                                                             
                                                                      
        if (rtems_rfs_buffer_dirty (handle))                          
   34690:	e5d53000 	ldrb	r3, [r5]                                     <== NOT EXECUTED
   34694:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   34698:	0a000006 	beq	346b8 <rtems_rfs_buffer_handle_release+0xfc>  <== 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 );                               
   3469c:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
   346a0:	e5951008 	ldr	r1, [r5, #8]                                  <== NOT EXECUTED
   346a4:	ebff5f5a 	bl	c414 <_Chain_Append>                           <== NOT EXECUTED
        {                                                             
          rtems_chain_append (&fs->release_modified,                  
                              rtems_rfs_buffer_link (handle));        
          fs->release_modified_count++;                               
   346a8:	e594306c 	ldr	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   346ac:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   346b0:	e584306c 	str	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   346b4:	ea000005 	b	346d0 <rtems_rfs_buffer_handle_release+0x114>   <== NOT EXECUTED
   346b8:	e2840050 	add	r0, r4, #80	; 0x50                            <== NOT EXECUTED
   346bc:	e5951008 	ldr	r1, [r5, #8]                                  <== NOT EXECUTED
   346c0:	ebff5f53 	bl	c414 <_Chain_Append>                           <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
          rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
          fs->release_count++;                                        
   346c4:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   346c8:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   346cc:	e584305c 	str	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
    handle->buffer = NULL;                                            
   346d0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   346d4:	e5853008 	str	r3, [r5, #8]                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   346d8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   346dc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000346e0 <rtems_rfs_buffer_handle_request>: int rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle, rtems_rfs_buffer_block block, bool read) {
   346e0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
   346e4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the handle has a buffer release it. This allows a handle to be reused
   * without needing to close then open it again.                     
   */                                                                 
  if (rtems_rfs_buffer_handle_has_block (handle))                     
   346e8:	e5911008 	ldr	r1, [r1, #8]                                  <== NOT EXECUTED
   346ec:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,         
                                 rtems_rfs_buffer_handle* handle,     
                                 rtems_rfs_buffer_block   block,      
                                 bool                     read)       
{                                                                     
   346f0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   346f4:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   346f8:	e20380ff 	and	r8, r3, #255	; 0xff                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the handle has a buffer release it. This allows a handle to be reused
   * without needing to close then open it again.                     
   */                                                                 
  if (rtems_rfs_buffer_handle_has_block (handle))                     
   346fc:	0a00000d 	beq	34738 <rtems_rfs_buffer_handle_request+0x58>  <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Treat block 0 as special to handle the loading of the super block.
     */                                                               
    if (block && (rtems_rfs_buffer_bnum (handle) == block))           
   34700:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   34704:	0a000003 	beq	34718 <rtems_rfs_buffer_handle_request+0x38>  <== NOT EXECUTED
   34708:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
   3470c:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   34710:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   34714:	08bd81f0 	popeq	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
      printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
              rtems_rfs_buffer_bnum (handle));                        
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
   34718:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3471c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   34720:	ebffffa5 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
    if (rc > 0)                                                       
   34724:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   34728:	c8bd81f0 	popgt	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
      return rc;                                                      
    handle->dirty = false;                                            
   3472c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    handle->bnum = 0;                                                 
   34730:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
              rtems_rfs_buffer_bnum (handle));                        
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
    if (rc > 0)                                                       
      return rc;                                                      
    handle->dirty = false;                                            
   34734:	e5c53000 	strb	r3, [r5]                                     <== NOT EXECUTED
   * currently attached to a handle. If it is share the access. A buffer could
   * be shared where different parts of the block have separate functions. An
   * example is an inode block and the file system needs to handle 2 inodes in
   * the same block at the same time.                                 
   */                                                                 
  if (fs->buffers_count)                                              
   34738:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   3473c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Check the active buffer list for shared buffers.               
     */                                                               
    handle->buffer = rtems_rfs_scan_chain (&fs->buffers,              
   34740:	12841040 	addne	r1, r4, #64	; 0x40                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->last;                                             
   34744:	15943048 	ldrne	r3, [r4, #72]	; 0x48                        <== NOT EXECUTED
   * currently attached to a handle. If it is share the access. A buffer could
   * be shared where different parts of the block have separate functions. An
   * example is an inode block and the file system needs to handle 2 inodes in
   * the same block at the same time.                                 
   */                                                                 
  if (fs->buffers_count)                                              
   34748:	1a00000d 	bne	34784 <rtems_rfs_buffer_handle_request+0xa4>  <== NOT EXECUTED
   3474c:	ea000010 	b	34794 <rtems_rfs_buffer_handle_request+0xb4>    <== NOT EXECUTED
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
   34750:	e5930038 	ldr	r0, [r3, #56]	; 0x38                          <== NOT EXECUTED
   34754:	e1500006 	cmp	r0, r6                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
   34758:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
   3475c:	1a000007 	bne	34780 <rtems_rfs_buffer_handle_request+0xa0>  <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))            
        printf (": found block=%" PRIuPTR "\n",                       
                ((intptr_t)(buffer->user)));                          
                                                                      
      (*count)--;                                                     
   34760:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
   34764:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   34768:	e584204c 	str	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   3476c:	ebff5f33 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
   34770:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   34774:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
   34778:	e5873004 	str	r3, [r7, #4]                                  <== NOT EXECUTED
   3477c:	ea000003 	b	34790 <rtems_rfs_buffer_handle_request+0xb0>    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(                     
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->previous;                                          
   34780:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
  node = rtems_chain_last (chain);                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
   34784:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   34788:	1afffff0 	bne	34750 <rtems_rfs_buffer_handle_request+0x70>  <== NOT EXECUTED
   3478c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
  if (fs->buffers_count)                                              
  {                                                                   
    /*                                                                
     * Check the active buffer list for shared buffers.               
     */                                                               
    handle->buffer = rtems_rfs_scan_chain (&fs->buffers,              
   34790:	e5857008 	str	r7, [r5, #8]                                  <== NOT EXECUTED
  /*                                                                  
   * If the buffer has not been found check the local cache of released
   * buffers. There are release and released modified lists to preserve the
   * state.                                                           
   */                                                                 
  if (!rtems_rfs_fs_no_local_cache (fs) &&                            
   34794:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   34798:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
   3479c:	1a000036 	bne	3487c <rtems_rfs_buffer_handle_request+0x19c> <== NOT EXECUTED
      !rtems_rfs_buffer_handle_has_block (handle))                    
   347a0:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
   347a4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   347a8:	1a000033 	bne	3487c <rtems_rfs_buffer_handle_request+0x19c> <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
   347ac:	e594205c 	ldr	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   347b0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
   347b4:	12841050 	addne	r1, r4, #80	; 0x50                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->last;                                             
   347b8:	15943058 	ldrne	r3, [r4, #88]	; 0x58                        <== NOT EXECUTED
      !rtems_rfs_buffer_handle_has_block (handle))                    
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
   347bc:	1a00000d 	bne	347f8 <rtems_rfs_buffer_handle_request+0x118> <== NOT EXECUTED
   347c0:	ea000010 	b	34808 <rtems_rfs_buffer_handle_request+0x128>   <== NOT EXECUTED
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
   347c4:	e5930038 	ldr	r0, [r3, #56]	; 0x38                          <== NOT EXECUTED
   347c8:	e1500006 	cmp	r0, r6                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
   347cc:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
   347d0:	1a000007 	bne	347f4 <rtems_rfs_buffer_handle_request+0x114> <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))            
        printf (": found block=%" PRIuPTR "\n",                       
                ((intptr_t)(buffer->user)));                          
                                                                      
      (*count)--;                                                     
   347d4:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   347d8:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   347dc:	e584205c 	str	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
   347e0:	ebff5f16 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
   347e4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   347e8:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
   347ec:	e5873004 	str	r3, [r7, #4]                                  <== NOT EXECUTED
   347f0:	ea000003 	b	34804 <rtems_rfs_buffer_handle_request+0x124>   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(                     
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->previous;                                          
   347f4:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
  node = rtems_chain_last (chain);                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
   347f8:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   347fc:	1afffff0 	bne	347c4 <rtems_rfs_buffer_handle_request+0xe4>  <== NOT EXECUTED
   34800:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
   34804:	e5857008 	str	r7, [r5, #8]                                  <== NOT EXECUTED
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
   34808:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
   3480c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   34810:	1a000019 	bne	3487c <rtems_rfs_buffer_handle_request+0x19c> <== NOT EXECUTED
        fs->release_modified_count)                                   
   34814:	e594206c 	ldr	r2, [r4, #108]	; 0x6c                         <== NOT EXECUTED
    if (fs->release_count)                                            
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
   34818:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        fs->release_modified_count)                                   
    {                                                                 
      handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,   
   3481c:	12841060 	addne	r1, r4, #96	; 0x60                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->last;                                             
   34820:	15943068 	ldrne	r3, [r4, #104]	; 0x68                       <== NOT EXECUTED
    if (fs->release_count)                                            
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
   34824:	1a00000d 	bne	34860 <rtems_rfs_buffer_handle_request+0x180> <== NOT EXECUTED
   34828:	ea000013 	b	3487c <rtems_rfs_buffer_handle_request+0x19c>   <== NOT EXECUTED
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
   3482c:	e5930038 	ldr	r0, [r3, #56]	; 0x38                          <== NOT EXECUTED
   34830:	e1500006 	cmp	r0, r6                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
   34834:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
   34838:	1a000007 	bne	3485c <rtems_rfs_buffer_handle_request+0x17c> <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))            
        printf (": found block=%" PRIuPTR "\n",                       
                ((intptr_t)(buffer->user)));                          
                                                                      
      (*count)--;                                                     
   3483c:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   34840:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   34844:	e584206c 	str	r2, [r4, #108]	; 0x6c                         <== NOT EXECUTED
   34848:	ebff5efc 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
   3484c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   34850:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
   34854:	e5873004 	str	r3, [r7, #4]                                  <== NOT EXECUTED
   34858:	ea000003 	b	3486c <rtems_rfs_buffer_handle_request+0x18c>   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(                     
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->previous;                                          
   3485c:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
  node = rtems_chain_last (chain);                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
   34860:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   34864:	1afffff0 	bne	3482c <rtems_rfs_buffer_handle_request+0x14c> <== NOT EXECUTED
   34868:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
                                             &fs->release_modified_count,
                                             block);                  
      /*                                                              
       * If we found a buffer retain the dirty buffer state.          
       */                                                             
      if (rtems_rfs_buffer_handle_has_block (handle))                 
   3486c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
        rtems_rfs_buffer_mark_dirty (handle);                         
   34870:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
        fs->release_modified_count)                                   
    {                                                                 
      handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,   
   34874:	e5857008 	str	r7, [r5, #8]                                  <== NOT EXECUTED
                                             block);                  
      /*                                                              
       * If we found a buffer retain the dirty buffer state.          
       */                                                             
      if (rtems_rfs_buffer_handle_has_block (handle))                 
        rtems_rfs_buffer_mark_dirty (handle);                         
   34878:	15c53000 	strbne	r3, [r5]                                   <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * If not located we request the buffer from the I/O layer.         
   */                                                                 
  if (!rtems_rfs_buffer_handle_has_block (handle))                    
   3487c:	e5957008 	ldr	r7, [r5, #8]                                  <== NOT EXECUTED
   34880:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   34884:	1a000009 	bne	348b0 <rtems_rfs_buffer_handle_request+0x1d0> <== NOT EXECUTED
  {                                                                   
    rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
   34888:	e2853008 	add	r3, r5, #8                                    <== NOT EXECUTED
   3488c:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   34890:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34894:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   34898:	eb002039 	bl	3c984 <rtems_rfs_buffer_bdbuf_request>         <== NOT EXECUTED
                                                                      
    rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));        
   3489c:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
                                                                      
    if (rc > 0)                                                       
   348a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
   348a4:	e5837000 	str	r7, [r3]                                      <== NOT EXECUTED
   348a8:	e5837004 	str	r7, [r3, #4]                                  <== NOT EXECUTED
   348ac:	c8bd81f0 	popgt	{r4, r5, r6, r7, r8, pc}                    <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Increase the reference count of the buffer.                      
   */                                                                 
  rtems_rfs_buffer_refs_up (handle);                                  
   348b0:	e5951008 	ldr	r1, [r5, #8]                                  <== NOT EXECUTED
   348b4:	e5913034 	ldr	r3, [r1, #52]	; 0x34                          <== NOT EXECUTED
   348b8:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   348bc:	e5813034 	str	r3, [r1, #52]	; 0x34                          <== 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 );                               
   348c0:	e2840040 	add	r0, r4, #64	; 0x40                            <== NOT EXECUTED
   348c4:	ebff5ed2 	bl	c414 <_Chain_Append>                           <== NOT EXECUTED
  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));  
  fs->buffers_count++;                                                
   348c8:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
   348cc:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
  /*                                                                  
   * Increase the reference count of the buffer.                      
   */                                                                 
  rtems_rfs_buffer_refs_up (handle);                                  
  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));  
  fs->buffers_count++;                                                
   348d0:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   348d4:	e584204c 	str	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
   348d8:	e5836038 	str	r6, [r3, #56]	; 0x38                          <== NOT EXECUTED
  handle->bnum = block;                                               
   348dc:	e5856004 	str	r6, [r5, #4]                                  <== NOT EXECUTED
   348e0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
            block, read ? "read" : "get", handle->buffer->block,      
            handle->buffer->references);                              
                                                                      
  return 0;                                                           
}                                                                     
   348e4:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00034564 <rtems_rfs_buffer_open>: return rc; } int rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs) {
   34564:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   34568:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
   3456c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  struct stat st;                                                     
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
    printf ("rtems-rfs: buffer-open: opening: %s\n", name);           
                                                                      
  if (stat (name, &st) < 0)                                           
   34570:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   34574:	ebff522e 	bl	8e34 <stat>                                    <== NOT EXECUTED
   34578:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3457c:	b3a00002 	movlt	r0, #2                                      <== NOT EXECUTED
   34580:	ba00000b 	blt	345b4 <rtems_rfs_buffer_open+0x50>            <== NOT EXECUTED
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  /*                                                                  
   * Is the device a block device ?                                   
   */                                                                 
  if (!S_ISBLK (st.st_mode))                                          
   34584:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   34588:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   3458c:	e3530a06 	cmp	r3, #24576	; 0x6000                           <== NOT EXECUTED
   34590:	1a000006 	bne	345b0 <rtems_rfs_buffer_open+0x4c>            <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Check that device is registred as a block device and lock it.    
   */                                                                 
  fs->disk = rtems_disk_obtain (st.st_rdev);                          
   34594:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   34598:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   3459c:	ebff473e 	bl	629c <rtems_disk_obtain>                       <== NOT EXECUTED
  if (!fs->disk)                                                      
   345a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Check that device is registred as a block device and lock it.    
   */                                                                 
  fs->disk = rtems_disk_obtain (st.st_rdev);                          
   345a4:	e584000c 	str	r0, [r4, #12]                                 <== NOT EXECUTED
  if (!fs->disk)                                                      
   345a8:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
   345ac:	1a000000 	bne	345b4 <rtems_rfs_buffer_open+0x50>            <== NOT EXECUTED
   345b0:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
    printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
            rtems_rfs_fs_media_blocks (fs),                           
            rtems_rfs_fs_media_block_size (fs));                      
                                                                      
  return 0;                                                           
}                                                                     
   345b4:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
   345b8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

000344f0 <rtems_rfs_buffer_setblksize>: int rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size) {
   344f0:	e92d4031 	push	{r0, r4, r5, lr}                             <== NOT EXECUTED
   344f4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   344f8:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
   344fc:	e5241004 	str	r1, [r4, #-4]!                                <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
    printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size); 
                                                                      
  rc = rtems_rfs_buffers_release (fs);                                
   34500:	ebffffdc 	bl	34478 <rtems_rfs_buffers_release>              <== NOT EXECUTED
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
    printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_buffer_sync (fs);                                    
   34504:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34508:	ebffffec 	bl	344c0 <rtems_rfs_buffer_sync>                  <== NOT EXECUTED
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
    printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
            rc, strerror (rc));                                       
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);     
   3450c:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
   34510:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   34514:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   34518:	e59f1018 	ldr	r1, [pc, #24]	; 34538 <rtems_rfs_buffer_setblksize+0x48><== NOT EXECUTED
   3451c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   34520:	e593f028 	ldr	pc, [r3, #40]	; 0x28                          <== NOT EXECUTED
  if (rc < 0)                                                         
   34524:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   34528:	aa000001 	bge	34534 <rtems_rfs_buffer_setblksize+0x44>      <== NOT EXECUTED
    rc = errno;                                                       
   3452c:	eb002273 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   34530:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
#endif                                                                
  return rc;                                                          
}                                                                     
   34534:	e8bd8038 	pop	{r3, r4, r5, pc}                              <== NOT EXECUTED
                                                                      

000344c0 <rtems_rfs_buffer_sync>: /* * @todo Split in the separate files for each type. */ #if RTEMS_RFS_USE_LIBBLOCK sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
   344c0:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
  return rc;                                                          
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)                     
{                                                                     
   344c4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   344c8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * @todo Split in the separate files for each type.                 
   */                                                                 
#if RTEMS_RFS_USE_LIBBLOCK                                            
  sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));                
   344cc:	e8930003 	ldm	r3, {r0, r1}                                  <== NOT EXECUTED
   344d0:	ebff3ca2 	bl	3760 <rtems_bdbuf_syncdev>                     <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
   344d4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   344d8:	13a05005 	movne	r5, #5                                      <== NOT EXECUTED
   344dc:	03a05000 	moveq	r5, #0                                      <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                
      printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",     
              rtems_status_text (sc));                                
    result = EIO;                                                     
  }                                                                   
  rtems_disk_release (fs->disk);                                      
   344e0:	e594000c 	ldr	r0, [r4, #12]                                 <== NOT EXECUTED
   344e4:	ebff47e8 	bl	648c <rtems_disk_release>                      <== NOT EXECUTED
      printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",   
              result, strerror (result));                             
  }                                                                   
#endif                                                                
  return result;                                                      
}                                                                     
   344e8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   344ec:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00034478 <rtems_rfs_buffers_release>: int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) {
   34478:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
    printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "         
            "release:%" PRIu32 " release-modified:%" PRIu32 "\n",     
            fs->buffers_count, fs->release_count, fs->release_modified_count);
                                                                      
  rc = rtems_rfs_release_chain (&fs->release,                         
   3447c:	e280105c 	add	r1, r0, #92	; 0x5c                            <== NOT EXECUTED
  return rrc;                                                         
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)                 
{                                                                     
   34480:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
    printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "         
            "release:%" PRIu32 " release-modified:%" PRIu32 "\n",     
            fs->buffers_count, fs->release_count, fs->release_modified_count);
                                                                      
  rc = rtems_rfs_release_chain (&fs->release,                         
   34484:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   34488:	e2800050 	add	r0, r0, #80	; 0x50                            <== NOT EXECUTED
   3448c:	ebffffdd 	bl	34408 <rtems_rfs_release_chain>                <== NOT EXECUTED
                                &fs->release_count,                   
                                false);                               
  if ((rc > 0) && (rrc == 0))                                         
    rrc = rc;                                                         
  rc = rtems_rfs_release_chain (&fs->release_modified,                
   34490:	e284106c 	add	r1, r4, #108	; 0x6c                           <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
    printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "         
            "release:%" PRIu32 " release-modified:%" PRIu32 "\n",     
            fs->buffers_count, fs->release_count, fs->release_modified_count);
                                                                      
  rc = rtems_rfs_release_chain (&fs->release,                         
   34494:	e1c05fc0 	bic	r5, r0, r0, asr #31                           <== NOT EXECUTED
                                &fs->release_count,                   
                                false);                               
  if ((rc > 0) && (rrc == 0))                                         
    rrc = rc;                                                         
  rc = rtems_rfs_release_chain (&fs->release_modified,                
   34498:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3449c:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
   344a0:	ebffffd8 	bl	34408 <rtems_rfs_release_chain>                <== NOT EXECUTED
                                &fs->release_modified_count,          
                                true);                                
  if ((rc > 0) && (rrc == 0))                                         
   344a4:	e2753001 	rsbs	r3, r5, #1                                   <== NOT EXECUTED
   344a8:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
   344ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   344b0:	d3a03000 	movle	r3, #0                                      <== NOT EXECUTED
    rrc = rc;                                                         
                                                                      
  return rrc;                                                         
}                                                                     
   344b4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   344b8:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
   344bc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00034fa4 <rtems_rfs_dir_add_entry>: rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, const char* name, size_t length, rtems_rfs_ino ino) {
   34fa4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   34fa8:	e24dd084 	sub	sp, sp, #132	; 0x84                           <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%zd\n", length);                                   
  }                                                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34fac:	e28d8018 	add	r8, sp, #24                                   <== NOT EXECUTED
rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,                  
                         rtems_rfs_inode_handle* dir,                 
                         const char*             name,                
                         size_t                  length,              
                         rtems_rfs_ino           ino)                 
{                                                                     
   34fb0:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%zd\n", length);                                   
  }                                                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34fb4:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,                  
                         rtems_rfs_inode_handle* dir,                 
                         const char*             name,                
                         size_t                  length,              
                         rtems_rfs_ino           ino)                 
{                                                                     
   34fb8:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
   34fbc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   34fc0:	e59d60a8 	ldr	r6, [sp, #168]	; 0xa8                         <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%zd\n", length);                                   
  }                                                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34fc4:	ebfffcb5 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34fc8:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   34fcc:	ca000095 	bgt	35228 <rtems_rfs_dir_add_entry+0x284>         <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   34fd0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
   34fd4:	e285000a 	add	r0, r5, #10                                   <== NOT EXECUTED
   34fd8:	e58d307c 	str	r3, [sp, #124]	; 0x7c                         <== NOT EXECUTED
   34fdc:	e5cd3068 	strb	r3, [sp, #104]	; 0x68                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34fe0:	e58d306c 	str	r3, [sp, #108]	; 0x6c                         <== NOT EXECUTED
  handle->buffer = NULL;                                              
   34fe4:	e58d3070 	str	r3, [sp, #112]	; 0x70                         <== NOT EXECUTED
 * @param bpos A pointer to the block position.                       
 */                                                                   
static inline void                                                    
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)             
{                                                                     
  bpos->bno = 0;                                                      
   34fe8:	e58d3074 	str	r3, [sp, #116]	; 0x74                         <== NOT EXECUTED
  bpos->boff = 0;                                                     
   34fec:	e58d3078 	str	r3, [sp, #120]	; 0x78                         <== NOT EXECUTED
   34ff0:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
    /*                                                                
     * Locate the first block. If an error the block will be 0. If the map is
     * empty which happens when creating a directory and adding the first entry
     * the seek will return ENXIO. In this case we need to grow the directory.
     */                                                               
    rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);          
   34ff4:	e28da080 	add	sl, sp, #128	; 0x80                           <== NOT EXECUTED
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
   34ff8:	e1a07005 	mov	r7, r5                                        <== NOT EXECUTED
    /*                                                                
     * Locate the first block. If an error the block will be 0. If the map is
     * empty which happens when creating a directory and adding the first entry
     * the seek will return ENXIO. In this case we need to grow the directory.
     */                                                               
    rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);          
   34ffc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35000:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   35004:	e28d2074 	add	r2, sp, #116	; 0x74                           <== NOT EXECUTED
   35008:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   3500c:	ebfff9a8 	bl	336b4 <rtems_rfs_block_map_find>               <== NOT EXECUTED
    if (rc > 0)                                                       
   35010:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   35014:	d3a05001 	movle	r5, #1                                      <== NOT EXECUTED
   35018:	da000009 	ble	35044 <rtems_rfs_dir_add_entry+0xa0>          <== NOT EXECUTED
    {                                                                 
      if (rc != ENXIO)                                                
   3501c:	e3590006 	cmp	r9, #6                                        <== NOT EXECUTED
   35020:	1a00007a 	bne	35210 <rtems_rfs_dir_add_entry+0x26c>         <== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       * We have reached the end of the directory so add a block.     
       */                                                             
      rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);            
   35024:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35028:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   3502c:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   35030:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   35034:	ebfffb3b 	bl	33d28 <rtems_rfs_block_map_grow>               <== NOT EXECUTED
      if (rc > 0)                                                     
   35038:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   3503c:	ca000073 	bgt	35210 <rtems_rfs_dir_add_entry+0x26c>         <== NOT EXECUTED
   35040:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
   35044:	e59dc074 	ldr	ip, [sp, #116]	; 0x74                         <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
   35048:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
   3504c:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
   35050:	e28d1068 	add	r1, sp, #104	; 0x68                           <== NOT EXECUTED
   35054:	e59d2080 	ldr	r2, [sp, #128]	; 0x80                         <== NOT EXECUTED
   35058:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
   3505c:	e58dc074 	str	ip, [sp, #116]	; 0x74                         <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
   35060:	ebfffd9e 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
    if (rc > 0)                                                       
   35064:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   35068:	ca000068 	bgt	35210 <rtems_rfs_dir_add_entry+0x26c>         <== NOT EXECUTED
                "block buffer req failed for ino %" PRIu32 ": %d: %s\n",
                rtems_rfs_inode_ino (dir), rc, strerror (rc));        
      break;                                                          
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
   3506c:	e59d3070 	ldr	r3, [sp, #112]	; 0x70                         <== NOT EXECUTED
                                                                      
    if (!read)                                                        
   35070:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                "block buffer req failed for ino %" PRIu32 ": %d: %s\n",
                rtems_rfs_inode_ino (dir), rc, strerror (rc));        
      break;                                                          
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
   35074:	e5935020 	ldr	r5, [r3, #32]                                 <== NOT EXECUTED
                                                                      
    if (!read)                                                        
      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));             
   35078:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
   3507c:	03a010ff 	moveq	r1, #255	; 0xff                             <== NOT EXECUTED
   35080:	05942008 	ldreq	r2, [r4, #8]                                <== NOT EXECUTED
   35084:	0b002cd4 	bleq	403dc <memset>                               <== NOT EXECUTED
                                                                      
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   35088:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
   3508c:	e241300a 	sub	r3, r1, #10                                   <== NOT EXECUTED
   35090:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   35094:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
   35098:	ea000058 	b	35200 <rtems_rfs_dir_add_entry+0x25c>           <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   3509c:	e5d50008 	ldrb	r0, [r5, #8]                                 <== NOT EXECUTED
   350a0:	e5d53009 	ldrb	r3, [r5, #9]                                 <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   350a4:	e59fb188 	ldr	fp, [pc, #392]	; 35234 <rtems_rfs_dir_add_entry+0x290><== NOT EXECUTED
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   350a8:	e1833400 	orr	r3, r3, r0, lsl #8                            <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   350ac:	e153000b 	cmp	r3, fp                                        <== NOT EXECUTED
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   350b0:	e285b008 	add	fp, r5, #8                                    <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   350b4:	e5d5e001 	ldrb	lr, [r5, #1]                                 <== NOT EXECUTED
   350b8:	e5d50003 	ldrb	r0, [r5, #3]                                 <== NOT EXECUTED
   350bc:	e5d5c002 	ldrb	ip, [r5, #2]                                 <== NOT EXECUTED
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   350c0:	e58db010 	str	fp, [sp, #16]                                 <== NOT EXECUTED
   350c4:	e285b009 	add	fp, r5, #9                                    <== NOT EXECUTED
   350c8:	e58db00c 	str	fp, [sp, #12]                                 <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   350cc:	e1a09005 	mov	r9, r5                                        <== NOT EXECUTED
   350d0:	e4d9b001 	ldrb	fp, [r9], #1                                 <== NOT EXECUTED
   350d4:	e1800c0b 	orr	r0, r0, fp, lsl #24                           <== NOT EXECUTED
   350d8:	e180080e 	orr	r0, r0, lr, lsl #16                           <== NOT EXECUTED
   350dc:	e285e003 	add	lr, r5, #3                                    <== NOT EXECUTED
   350e0:	e285b002 	add	fp, r5, #2                                    <== NOT EXECUTED
   350e4:	e58de008 	str	lr, [sp, #8]                                  <== NOT EXECUTED
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   350e8:	1a00002d 	bne	351a4 <rtems_rfs_dir_add_entry+0x200>         <== NOT EXECUTED
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
   350ec:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
   350f0:	e0622001 	rsb	r2, r2, r1                                    <== NOT EXECUTED
   350f4:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
   350f8:	2affffbf 	bcs	34ffc <rtems_rfs_dir_add_entry+0x58>          <== NOT EXECUTED
   350fc:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
            (rtems_rfs_fs_block_size (fs) - offset))                  
        {                                                             
          uint32_t hash;                                              
          hash = rtems_rfs_dir_hash (name, length);                   
   35100:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   35104:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
   35108:	e1a07005 	mov	r7, r5                                        <== NOT EXECUTED
   3510c:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
   35110:	eb001e29 	bl	3c9bc <rtems_rfs_dir_hash>                     <== NOT EXECUTED
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
   35114:	e1a0c820 	lsr	ip, r0, #16                                   <== NOT EXECUTED
   35118:	e5c7c005 	strb	ip, [r7, #5]                                 <== NOT EXECUTED
   3511c:	e5c70007 	strb	r0, [r7, #7]                                 <== NOT EXECUTED
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
   35120:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   35124:	e1a0c826 	lsr	ip, r6, #16                                   <== NOT EXECUTED
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
            (rtems_rfs_fs_block_size (fs) - offset))                  
        {                                                             
          uint32_t hash;                                              
          hash = rtems_rfs_dir_hash (name, length);                   
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
   35128:	e1a0ec20 	lsr	lr, r0, #24                                   <== NOT EXECUTED
   3512c:	e1a01420 	lsr	r1, r0, #8                                    <== NOT EXECUTED
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
   35130:	e1a02c26 	lsr	r2, r6, #24                                   <== NOT EXECUTED
   35134:	e1a00426 	lsr	r0, r6, #8                                    <== NOT EXECUTED
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
            (rtems_rfs_fs_block_size (fs) - offset))                  
        {                                                             
          uint32_t hash;                                              
          hash = rtems_rfs_dir_hash (name, length);                   
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
   35138:	e5c71006 	strb	r1, [r7, #6]                                 <== NOT EXECUTED
   3513c:	e5c7e004 	strb	lr, [r7, #4]                                 <== NOT EXECUTED
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
   35140:	e4c3200a 	strb	r2, [r3], #10                                <== NOT EXECUTED
   35144:	e5c9c000 	strb	ip, [r9]                                     <== NOT EXECUTED
   35148:	e5cb0000 	strb	r0, [fp]                                     <== NOT EXECUTED
   3514c:	e59db008 	ldr	fp, [sp, #8]                                  <== NOT EXECUTED
   35150:	e5cb6000 	strb	r6, [fp]                                     <== NOT EXECUTED
          rtems_rfs_dir_set_entry_length (entry,                      
   35154:	e59de010 	ldr	lr, [sp, #16]                                 <== NOT EXECUTED
   35158:	e285200a 	add	r2, r5, #10                                   <== NOT EXECUTED
   3515c:	e1a01422 	lsr	r1, r2, #8                                    <== NOT EXECUTED
   35160:	e5ce1000 	strb	r1, [lr]                                     <== NOT EXECUTED
   35164:	e59d000c 	ldr	r0, [sp, #12]                                 <== NOT EXECUTED
   35168:	e5c02000 	strb	r2, [r0]                                     <== NOT EXECUTED
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
   3516c:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
   35170:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   35174:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   35178:	eb002c10 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
          rtems_rfs_buffer_mark_dirty (&buffer);                      
   3517c:	e28d1084 	add	r1, sp, #132	; 0x84                           <== NOT EXECUTED
   35180:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   35184:	e561301c 	strb	r3, [r1, #-28]!                              <== NOT EXECUTED
          rtems_rfs_buffer_handle_close (fs, &buffer);                
   35188:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3518c:	ebfffdd5 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
          rtems_rfs_block_map_close (fs, &map);                       
   35190:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35194:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   35198:	ebfffbce 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
   3519c:	e3a09000 	mov	r9, #0                                        <== NOT EXECUTED
          return 0;                                                   
   351a0:	ea000020 	b	35228 <rtems_rfs_dir_add_entry+0x284>           <== NOT EXECUTED
        }                                                             
                                                                      
        break;                                                        
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
   351a4:	e353000a 	cmp	r3, #10                                       <== NOT EXECUTED
   351a8:	da00000a 	ble	351d8 <rtems_rfs_dir_add_entry+0x234>         <== NOT EXECUTED
   351ac:	e190040c 	orrs	r0, r0, ip, lsl #8                           <== NOT EXECUTED
   351b0:	e594e018 	ldr	lr, [r4, #24]                                 <== NOT EXECUTED
   351b4:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
   351b8:	03a0c001 	moveq	ip, #1                                      <== NOT EXECUTED
   351bc:	e153000e 	cmp	r3, lr                                        <== NOT EXECUTED
   351c0:	238cc001 	orrcs	ip, ip, #1                                  <== NOT EXECUTED
   351c4:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   351c8:	1a000002 	bne	351d8 <rtems_rfs_dir_add_entry+0x234>         <== NOT EXECUTED
   351cc:	e594c010 	ldr	ip, [r4, #16]                                 <== NOT EXECUTED
   351d0:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
   351d4:	9a000007 	bls	351f8 <rtems_rfs_dir_add_entry+0x254>         <== NOT EXECUTED
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
          printf ("rtems-rfs: dir-add-entry: "                        
                  "bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
                  rtems_rfs_inode_ino (dir), elength, eino, offset);  
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
   351d8:	e28d1068 	add	r1, sp, #104	; 0x68                           <== NOT EXECUTED
   351dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   351e0:	ebfffdc0 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
        rtems_rfs_block_map_close (fs, &map);                         
   351e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   351e8:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   351ec:	ebfffbb9 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
   351f0:	e3a09005 	mov	r9, #5                                        <== NOT EXECUTED
        return EIO;                                                   
   351f4:	ea00000b 	b	35228 <rtems_rfs_dir_add_entry+0x284>           <== NOT EXECUTED
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
   351f8:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
        return EIO;                                                   
      }                                                               
                                                                      
      entry  += elength;                                              
   351fc:	e0855003 	add	r5, r5, r3                                    <== NOT EXECUTED
    if (!read)                                                        
      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));             
                                                                      
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   35200:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   35204:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   35208:	2affff7b 	bcs	34ffc <rtems_rfs_dir_add_entry+0x58>          <== NOT EXECUTED
   3520c:	eaffffa2 	b	3509c <rtems_rfs_dir_add_entry+0xf8>            <== NOT EXECUTED
      entry  += elength;                                              
      offset += elength;                                              
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
   35210:	e28d1068 	add	r1, sp, #104	; 0x68                           <== NOT EXECUTED
   35214:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35218:	ebfffdb2 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
   3521c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35220:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   35224:	ebfffbab 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   35228:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   3522c:	e28dd084 	add	sp, sp, #132	; 0x84                           <== NOT EXECUTED
   35230:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00034d3c <rtems_rfs_dir_del_entry>: int rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_ino ino, uint32_t offset) {
   34d3c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   34d40:	e24dd074 	sub	sp, sp, #116	; 0x74                           <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))                
    printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
            rtems_rfs_inode_ino (dir), ino, offset);                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34d44:	e28d7014 	add	r7, sp, #20                                   <== NOT EXECUTED
int                                                                   
rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,                  
                         rtems_rfs_inode_handle* dir,                 
                         rtems_rfs_ino           ino,                 
                         uint32_t                offset)              
{                                                                     
   34d48:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))                
    printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
            rtems_rfs_inode_ino (dir), ino, offset);                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34d4c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,                  
                         rtems_rfs_inode_handle* dir,                 
                         rtems_rfs_ino           ino,                 
                         uint32_t                offset)              
{                                                                     
   34d50:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
   34d54:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))                
    printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
            rtems_rfs_inode_ino (dir), ino, offset);                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34d58:	ebfffd50 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34d5c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   34d60:	ca00008b 	bgt	34f94 <rtems_rfs_dir_del_entry+0x258>         <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
   34d64:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
   34d68:	e28da070 	add	sl, sp, #112	; 0x70                           <== NOT EXECUTED
   34d6c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34d70:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   34d74:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   34d78:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   34d7c:	e58da000 	str	sl, [sp]                                      <== NOT EXECUTED
   34d80:	ebfffaac 	bl	33838 <rtems_rfs_block_map_seek>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34d84:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   34d88:	da000004 	ble	34da0 <rtems_rfs_dir_del_entry+0x64>          <== NOT EXECUTED
  {                                                                   
    if (rc == ENXIO)                                                  
   34d8c:	e3540006 	cmp	r4, #6                                        <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
   34d90:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34d94:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
  if (rc > 0)                                                         
  {                                                                   
    if (rc == ENXIO)                                                  
   34d98:	03a04002 	moveq	r4, #2                                      <== NOT EXECUTED
   34d9c:	ea00007b 	b	34f90 <rtems_rfs_dir_del_entry+0x254>           <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   34da0:	e5cd6064 	strb	r6, [sp, #100]	; 0x64                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34da4:	e58d6068 	str	r6, [sp, #104]	; 0x68                         <== NOT EXECUTED
  handle->buffer = NULL;                                              
   34da8:	e58d606c 	str	r6, [sp, #108]	; 0x6c                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Only search if the offset is 0 else we are at that position.     
   */                                                                 
  search = offset ? false : true;                                     
   34dac:	e2789001 	rsbs	r9, r8, #1                                   <== NOT EXECUTED
   34db0:	33a09000 	movcc	r9, #0                                      <== NOT EXECUTED
   34db4:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
                                                                      
  while (rc == 0)                                                     
   34db8:	ea00006d 	b	34f74 <rtems_rfs_dir_del_entry+0x238>           <== NOT EXECUTED
  {                                                                   
    uint8_t* entry;                                                   
    int      eoffset;                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
   34dbc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34dc0:	e28d1064 	add	r1, sp, #100	; 0x64                           <== NOT EXECUTED
   34dc4:	e59d2070 	ldr	r2, [sp, #112]	; 0x70                         <== NOT EXECUTED
   34dc8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   34dcc:	ebfffe43 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
    if (rc > 0)                                                       
   34dd0:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   34dd4:	c1a0400b 	movgt	r4, fp                                      <== NOT EXECUTED
   34dd8:	ca000067 	bgt	34f7c <rtems_rfs_dir_del_entry+0x240>         <== NOT EXECUTED
                                                                      
    /*                                                                
     * If we are searching start at the beginning of the block. If not searching
     * skip to the offset in the block.                               
     */                                                               
    if (search)                                                       
   34ddc:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   34de0:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
   34de4:	01a00008 	moveq	r0, r8                                      <== NOT EXECUTED
   34de8:	05951008 	ldreq	r1, [r5, #8]                                <== NOT EXECUTED
   34dec:	0b008095 	bleq	55048 <__umodsi3>                            <== NOT EXECUTED
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
   34df0:	e59d306c 	ldr	r3, [sp, #108]	; 0x6c                         <== NOT EXECUTED
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34df4:	e5952008 	ldr	r2, [r5, #8]                                  <== NOT EXECUTED
    if (search)                                                       
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
   34df8:	e5936020 	ldr	r6, [r3, #32]                                 <== NOT EXECUTED
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34dfc:	e242e00a 	sub	lr, r2, #10                                   <== NOT EXECUTED
    if (search)                                                       
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
   34e00:	e0866000 	add	r6, r6, r0                                    <== NOT EXECUTED
   34e04:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34e08:	ea00004a 	b	34f38 <rtems_rfs_dir_del_entry+0x1fc>           <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   34e0c:	e5d63009 	ldrb	r3, [r6, #9]                                 <== NOT EXECUTED
   34e10:	e5d67008 	ldrb	r7, [r6, #8]                                 <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   34e14:	e5d6c000 	ldrb	ip, [r6]                                     <== NOT EXECUTED
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   34e18:	e59f2180 	ldr	r2, [pc, #384]	; 34fa0 <rtems_rfs_dir_del_entry+0x264><== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   34e1c:	e5d61003 	ldrb	r1, [r6, #3]                                 <== NOT EXECUTED
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   34e20:	e1837407 	orr	r7, r3, r7, lsl #8                            <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   34e24:	e5d63001 	ldrb	r3, [r6, #1]                                 <== NOT EXECUTED
   34e28:	e1811c0c 	orr	r1, r1, ip, lsl #24                           <== NOT EXECUTED
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   34e2c:	e1570002 	cmp	r7, r2                                        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   34e30:	e1811803 	orr	r1, r1, r3, lsl #16                           <== NOT EXECUTED
   34e34:	e5d6a002 	ldrb	sl, [r6, #2]                                 <== NOT EXECUTED
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   34e38:	e2863008 	add	r3, r6, #8                                    <== NOT EXECUTED
   34e3c:	e286c009 	add	ip, r6, #9                                    <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   34e40:	0a00003e 	beq	34f40 <rtems_rfs_dir_del_entry+0x204>         <== NOT EXECUTED
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
   34e44:	e357000a 	cmp	r7, #10                                       <== NOT EXECUTED
   34e48:	da000047 	ble	34f6c <rtems_rfs_dir_del_entry+0x230>         <== NOT EXECUTED
   34e4c:	e191140a 	orrs	r1, r1, sl, lsl #8                           <== NOT EXECUTED
   34e50:	e5952018 	ldr	r2, [r5, #24]                                 <== NOT EXECUTED
   34e54:	13a0a000 	movne	sl, #0                                      <== NOT EXECUTED
   34e58:	03a0a001 	moveq	sl, #1                                      <== NOT EXECUTED
   34e5c:	e1570002 	cmp	r7, r2                                        <== NOT EXECUTED
   34e60:	238aa001 	orrcs	sl, sl, #1                                  <== NOT EXECUTED
   34e64:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   34e68:	1a00003f 	bne	34f6c <rtems_rfs_dir_del_entry+0x230>         <== NOT EXECUTED
   34e6c:	e595a010 	ldr	sl, [r5, #16]                                 <== NOT EXECUTED
   34e70:	e151000a 	cmp	r1, sl                                        <== NOT EXECUTED
   34e74:	8a00003c 	bhi	34f6c <rtems_rfs_dir_del_entry+0x230>         <== NOT EXECUTED
                  rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      if (ino == rtems_rfs_dir_entry_ino (entry))                     
   34e78:	e59da010 	ldr	sl, [sp, #16]                                 <== NOT EXECUTED
   34e7c:	e15a0001 	cmp	sl, r1                                        <== NOT EXECUTED
   34e80:	1a000028 	bne	34f28 <rtems_rfs_dir_del_entry+0x1ec>         <== NOT EXECUTED
   34e84:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
      {                                                               
        uint32_t remaining;                                           
        remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
   34e88:	e0808007 	add	r8, r0, r7                                    <== NOT EXECUTED
   34e8c:	e0688002 	rsb	r8, r8, r2                                    <== NOT EXECUTED
   34e90:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
        memmove (entry, entry + elength, remaining);                  
   34e94:	e0861007 	add	r1, r6, r7                                    <== NOT EXECUTED
   34e98:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   34e9c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   34ea0:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   34ea4:	e58dc00c 	str	ip, [sp, #12]                                 <== NOT EXECUTED
   34ea8:	eb002d00 	bl	402b0 <memmove>                                <== NOT EXECUTED
        memset (entry + remaining, 0xff, elength);                    
   34eac:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   34eb0:	e0860008 	add	r0, r6, r8                                    <== NOT EXECUTED
   34eb4:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   34eb8:	eb002d47 	bl	403dc <memset>                                 <== NOT EXECUTED
         * block and it is the last block in the map shrink the map.  
         *                                                            
         * @note We could check again to see if the new end block in the map is
         *       also empty. This way we could clean up an empty directory.
         */                                                           
        elength = rtems_rfs_dir_entry_length (entry);                 
   34ebc:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
   34ec0:	e8931008 	ldm	r3, {r3, ip}                                  <== NOT EXECUTED
   34ec4:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
   34ec8:	e5dc3000 	ldrb	r3, [ip]                                     <== NOT EXECUTED
   34ecc:	e1832402 	orr	r2, r3, r2, lsl #8                            <== NOT EXECUTED
   34ed0:	e59f30c8 	ldr	r3, [pc, #200]	; 34fa0 <rtems_rfs_dir_del_entry+0x264><== NOT EXECUTED
   34ed4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   34ed8:	035a0000 	cmpeq	sl, #0                                      <== NOT EXECUTED
   34edc:	1a00000d 	bne	34f18 <rtems_rfs_dir_del_entry+0x1dc>         <== NOT EXECUTED
                  " offset=%d last=%s\n",                             
                  ino, elength, block, eoffset,                       
                  rtems_rfs_block_map_last (&map) ? "yes" : "no");    
                                                                      
        if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&                 
            (eoffset == 0) && rtems_rfs_block_map_last (&map))        
   34ee0:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
                  "last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
                  " offset=%d last=%s\n",                             
                  ino, elength, block, eoffset,                       
                  rtems_rfs_block_map_last (&map) ? "yes" : "no");    
                                                                      
        if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&                 
   34ee4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   34ee8:	1a000002 	bne	34ef8 <rtems_rfs_dir_del_entry+0x1bc>         <== NOT EXECUTED
   34eec:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
   34ef0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   34ef4:	0a000003 	beq	34f08 <rtems_rfs_dir_del_entry+0x1cc>         <== NOT EXECUTED
   34ef8:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
   34efc:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   34f00:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   34f04:	1a000003 	bne	34f18 <rtems_rfs_dir_del_entry+0x1dc>         <== NOT EXECUTED
            (eoffset == 0) && rtems_rfs_block_map_last (&map))        
        {                                                             
          rc = rtems_rfs_block_map_shrink (fs, &map, 1);              
   34f08:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34f0c:	e28d1014 	add	r1, sp, #20                                   <== NOT EXECUTED
   34f10:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   34f14:	ebfffa8b 	bl	33948 <rtems_rfs_block_map_shrink>             <== NOT EXECUTED
                      "block map shrink failed for ino %" PRIu32 ": %d: %s\n",
                      rtems_rfs_inode_ino (dir), rc, strerror (rc));  
          }                                                           
        }                                                             
                                                                      
        rtems_rfs_buffer_mark_dirty (&buffer);                        
   34f18:	e28d1074 	add	r1, sp, #116	; 0x74                           <== NOT EXECUTED
   34f1c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   34f20:	e5613010 	strb	r3, [r1, #-16]!                              <== NOT EXECUTED
   34f24:	ea000015 	b	34f80 <rtems_rfs_dir_del_entry+0x244>           <== NOT EXECUTED
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
        return 0;                                                     
      }                                                               
                                                                      
      if (!search)                                                    
   34f28:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   34f2c:	0a00000e 	beq	34f6c <rtems_rfs_dir_del_entry+0x230>         <== NOT EXECUTED
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
   34f30:	e0800007 	add	r0, r0, r7                                    <== NOT EXECUTED
      {                                                               
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      entry   += elength;                                             
   34f34:	e0866007 	add	r6, r6, r7                                    <== NOT EXECUTED
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34f38:	e150000e 	cmp	r0, lr                                        <== NOT EXECUTED
   34f3c:	3affffb2 	bcc	34e0c <rtems_rfs_dir_del_entry+0xd0>          <== NOT EXECUTED
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
    }                                                                 
                                                                      
    if (rc == 0)                                                      
   34f40:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
   34f44:	1a000009 	bne	34f70 <rtems_rfs_dir_del_entry+0x234>         <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
   34f48:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34f4c:	e28d1014 	add	r1, sp, #20                                   <== NOT EXECUTED
   34f50:	e28d2070 	add	r2, sp, #112	; 0x70                           <== NOT EXECUTED
   34f54:	ebfffa2c 	bl	3380c <rtems_rfs_block_map_next_block>         <== NOT EXECUTED
      if (rc == ENXIO)                                                
   34f58:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
      eoffset += elength;                                             
    }                                                                 
                                                                      
    if (rc == 0)                                                      
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
   34f5c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
      if (rc == ENXIO)                                                
   34f60:	1a000003 	bne	34f74 <rtems_rfs_dir_del_entry+0x238>         <== NOT EXECUTED
   34f64:	e3a04002 	mov	r4, #2                                        <== NOT EXECUTED
   34f68:	ea000003 	b	34f7c <rtems_rfs_dir_del_entry+0x240>           <== NOT EXECUTED
   34f6c:	e3a0b005 	mov	fp, #5                                        <== NOT EXECUTED
   34f70:	e1a0400b 	mov	r4, fp                                        <== NOT EXECUTED
  /*                                                                  
   * Only search if the offset is 0 else we are at that position.     
   */                                                                 
  search = offset ? false : true;                                     
                                                                      
  while (rc == 0)                                                     
   34f74:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   34f78:	0affff8f 	beq	34dbc <rtems_rfs_dir_del_entry+0x80>          <== NOT EXECUTED
      if (rc == ENXIO)                                                
        rc = ENOENT;                                                  
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
   34f7c:	e28d1064 	add	r1, sp, #100	; 0x64                           <== NOT EXECUTED
   34f80:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34f84:	ebfffe57 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
   34f88:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34f8c:	e28d1014 	add	r1, sp, #20                                   <== NOT EXECUTED
   34f90:	ebfffc50 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   34f94:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34f98:	e28dd074 	add	sp, sp, #116	; 0x74                           <== NOT EXECUTED
   34f9c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00034908 <rtems_rfs_dir_empty>: } int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) {
   34908:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   3490c:	e24dd064 	sub	sp, sp, #100	; 0x64                           <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
    printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
                                                                      
  empty = true;                                                       
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34910:	e28d6004 	add	r6, sp, #4                                    <== NOT EXECUTED
   34914:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_dir_empty (rtems_rfs_file_system*  fs,                      
                     rtems_rfs_inode_handle* dir)                     
{                                                                     
   34918:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
    printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
                                                                      
  empty = true;                                                       
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   3491c:	ebfffe5f 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34920:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   34924:	ca000055 	bgt	34a80 <rtems_rfs_dir_empty+0x178>             <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);                
   34928:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3492c:	e28d5060 	add	r5, sp, #96	; 0x60                            <== NOT EXECUTED
   34930:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34934:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   34938:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   3493c:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
   34940:	ebfffbbc 	bl	33838 <rtems_rfs_block_map_seek>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34944:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_block_map_close (fs, &map);                             
   34948:	c1a00004 	movgt	r0, r4                                      <== NOT EXECUTED
   3494c:	c1a01006 	movgt	r1, r6                                      <== NOT EXECUTED
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);                
  if (rc > 0)                                                         
   34950:	ca000049 	bgt	34a7c <rtems_rfs_dir_empty+0x174>             <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   34954:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   34958:	e58d305c 	str	r3, [sp, #92]	; 0x5c                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   3495c:	e5cd3054 	strb	r3, [sp, #84]	; 0x54                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34960:	e58d3058 	str	r3, [sp, #88]	; 0x58                          <== NOT EXECUTED
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   34964:	e59f7120 	ldr	r7, [pc, #288]	; 34a8c <rtems_rfs_dir_empty+0x184><== NOT EXECUTED
  while (empty)                                                       
  {                                                                   
    uint8_t* entry;                                                   
    int      offset;                                                  
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
   34968:	e28d8054 	add	r8, sp, #84	; 0x54                            <== NOT EXECUTED
   3496c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34970:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   34974:	e59d2060 	ldr	r2, [sp, #96]	; 0x60                          <== NOT EXECUTED
   34978:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   3497c:	ebffff57 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
    if (rc > 0)                                                       
   34980:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   34984:	ca000037 	bgt	34a68 <rtems_rfs_dir_empty+0x160>             <== NOT EXECUTED
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34988:	e594e008 	ldr	lr, [r4, #8]                                  <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
    if (rc > 0)                                                       
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
   3498c:	e59d305c 	ldr	r3, [sp, #92]	; 0x5c                          <== NOT EXECUTED
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34990:	e24ee00a 	sub	lr, lr, #10                                   <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
    if (rc > 0)                                                       
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
   34994:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34998:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   3499c:	ea000024 	b	34a34 <rtems_rfs_dir_empty+0x12c>               <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
   349a0:	e5d30008 	ldrb	r0, [r3, #8]                                 <== NOT EXECUTED
   349a4:	e5d32009 	ldrb	r2, [r3, #9]                                 <== NOT EXECUTED
   349a8:	e1822400 	orr	r2, r2, r0, lsl #8                            <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   349ac:	e1520007 	cmp	r2, r7                                        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   349b0:	e5d3b000 	ldrb	fp, [r3]                                     <== NOT EXECUTED
   349b4:	e5d39001 	ldrb	r9, [r3, #1]                                 <== NOT EXECUTED
   349b8:	e5d3c002 	ldrb	ip, [r3, #2]                                 <== NOT EXECUTED
   349bc:	e5d30003 	ldrb	r0, [r3, #3]                                 <== NOT EXECUTED
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
   349c0:	0a00001d 	beq	34a3c <rtems_rfs_dir_empty+0x134>             <== NOT EXECUTED
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
   349c4:	e352000a 	cmp	r2, #10                                       <== NOT EXECUTED
   349c8:	da00001b 	ble	34a3c <rtems_rfs_dir_empty+0x134>             <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
   349cc:	e1800c0b 	orr	r0, r0, fp, lsl #24                           <== NOT EXECUTED
   349d0:	e1800809 	orr	r0, r0, r9, lsl #16                           <== NOT EXECUTED
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
   349d4:	e190040c 	orrs	r0, r0, ip, lsl #8                           <== NOT EXECUTED
   349d8:	e5949018 	ldr	r9, [r4, #24]                                 <== NOT EXECUTED
   349dc:	13a0c000 	movne	ip, #0                                      <== NOT EXECUTED
   349e0:	03a0c001 	moveq	ip, #1                                      <== NOT EXECUTED
   349e4:	e1520009 	cmp	r2, r9                                        <== NOT EXECUTED
   349e8:	238cc001 	orrcs	ip, ip, #1                                  <== NOT EXECUTED
   349ec:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   349f0:	1a000011 	bne	34a3c <rtems_rfs_dir_empty+0x134>             <== NOT EXECUTED
   349f4:	e5949010 	ldr	r9, [r4, #16]                                 <== NOT EXECUTED
   349f8:	e1500009 	cmp	r0, r9                                        <== NOT EXECUTED
   349fc:	8a00000e 	bhi	34a3c <rtems_rfs_dir_empty+0x134>             <== NOT EXECUTED
                                                                      
      /*                                                              
       * Ignore the current (.) and parent (..) entries. Anything else means
       * the directory is not empty.                                  
       */                                                             
      if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||             
   34a00:	e352000b 	cmp	r2, #11                                       <== NOT EXECUTED
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&               
   34a04:	05d3000a 	ldrbeq	r0, [r3, #10]                              <== NOT EXECUTED
                                                                      
      /*                                                              
       * Ignore the current (.) and parent (..) entries. Anything else means
       * the directory is not empty.                                  
       */                                                             
      if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||             
   34a08:	0a000005 	beq	34a24 <rtems_rfs_dir_empty+0x11c>             <== NOT EXECUTED
   34a0c:	e352000c 	cmp	r2, #12                                       <== NOT EXECUTED
   34a10:	1a000012 	bne	34a60 <rtems_rfs_dir_empty+0x158>             <== NOT EXECUTED
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&               
          ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||             
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||                
   34a14:	e5d3000a 	ldrb	r0, [r3, #10]                                <== NOT EXECUTED
   34a18:	e350002e 	cmp	r0, #46	; 0x2e                                <== NOT EXECUTED
   34a1c:	1a00000f 	bne	34a60 <rtems_rfs_dir_empty+0x158>             <== NOT EXECUTED
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE + 1] != '.')))             
   34a20:	e5d3000b 	ldrb	r0, [r3, #11]                                <== NOT EXECUTED
   34a24:	e350002e 	cmp	r0, #46	; 0x2e                                <== NOT EXECUTED
   34a28:	1a00000c 	bne	34a60 <rtems_rfs_dir_empty+0x158>             <== NOT EXECUTED
        empty = false;                                                
        break;                                                        
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
   34a2c:	e0811002 	add	r1, r1, r2                                    <== NOT EXECUTED
      {                                                               
        empty = false;                                                
        break;                                                        
      }                                                               
                                                                      
      entry  += elength;                                              
   34a30:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   34a34:	e151000e 	cmp	r1, lr                                        <== NOT EXECUTED
   34a38:	3affffd8 	bcc	349a0 <rtems_rfs_dir_empty+0x98>              <== NOT EXECUTED
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
   34a3c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34a40:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   34a44:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   34a48:	ebfffb6f 	bl	3380c <rtems_rfs_block_map_next_block>         <== NOT EXECUTED
      if (rc > 0)                                                     
   34a4c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   34a50:	daffffc5 	ble	3496c <rtems_rfs_dir_empty+0x64>              <== NOT EXECUTED
      {                                                               
        if (rc == ENXIO)                                              
   34a54:	e35a0006 	cmp	sl, #6                                        <== NOT EXECUTED
   34a58:	03a0a000 	moveq	sl, #0                                      <== NOT EXECUTED
   34a5c:	ea000001 	b	34a68 <rtems_rfs_dir_empty+0x160>               <== NOT EXECUTED
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ((rc == 0) && !empty)                                            
   34a60:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   34a64:	03a0a05a 	moveq	sl, #90	; 0x5a                              <== NOT EXECUTED
    rc = ENOTEMPTY;                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
   34a68:	e28d1054 	add	r1, sp, #84	; 0x54                            <== NOT EXECUTED
   34a6c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34a70:	ebffff9c 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
   34a74:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34a78:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
   34a7c:	ebfffd95 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   34a80:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   34a84:	e28dd064 	add	sp, sp, #100	; 0x64                           <== NOT EXECUTED
   34a88:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0003c9bc <rtems_rfs_dir_hash>: { uint32_t a,b,c; /* internal state */ union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */ /* Set up the internal state */ a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
   3c9bc:	e59f31b8 	ldr	r3, [pc, #440]	; 3cb7c <rtems_rfs_dir_hash+0x1c0><== NOT EXECUTED
   3c9c0:	e0813003 	add	r3, r1, r3                                    <== NOT EXECUTED
*/                                                                    
                                                                      
#define initval (20010928)                                            
uint32_t                                                              
rtems_rfs_dir_hash (const void *key, size_t length)                   
{                                                                     
   3c9c4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  uint32_t a,b,c;                             /* internal state */    
  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
                                                                      
  /* Set up the internal state */                                     
  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;              
   3c9c8:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
   3c9cc:	e1a0c003 	mov	ip, r3                                        <== NOT EXECUTED
                                                                      
  } else {                        /* need to read the key one byte at a time */
    const uint8_t *k = (const uint8_t *)key;                          
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
   3c9d0:	ea00002d 	b	3ca8c <rtems_rfs_dir_hash+0xd0>                 <== NOT EXECUTED
    {                                                                 
      a += k[0];                                                      
   3c9d4:	e550900a 	ldrb	r9, [r0, #-10]                               <== NOT EXECUTED
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
   3c9d8:	e5508002 	ldrb	r8, [r0, #-2]                                <== NOT EXECUTED
    const uint8_t *k = (const uint8_t *)key;                          
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
   3c9dc:	e550500b 	ldrb	r5, [r0, #-11]                               <== NOT EXECUTED
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
   3c9e0:	e5504003 	ldrb	r4, [r0, #-3]                                <== NOT EXECUTED
    const uint8_t *k = (const uint8_t *)key;                          
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
   3c9e4:	e1a09809 	lsl	r9, r9, #16                                   <== NOT EXECUTED
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
   3c9e8:	e1a08808 	lsl	r8, r8, #16                                   <== NOT EXECUTED
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
   3c9ec:	e550a00c 	ldrb	sl, [r0, #-12]                               <== NOT EXECUTED
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
   3c9f0:	e5506006 	ldrb	r6, [r0, #-6]                                <== NOT EXECUTED
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
   3c9f4:	e5507004 	ldrb	r7, [r0, #-4]                                <== NOT EXECUTED
    const uint8_t *k = (const uint8_t *)key;                          
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
   3c9f8:	e0899405 	add	r9, r9, r5, lsl #8                            <== NOT EXECUTED
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
   3c9fc:	e0888404 	add	r8, r8, r4, lsl #8                            <== NOT EXECUTED
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
   3ca00:	e5505009 	ldrb	r5, [r0, #-9]                                <== NOT EXECUTED
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
   3ca04:	e5504007 	ldrb	r4, [r0, #-7]                                <== NOT EXECUTED
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
   3ca08:	e550b001 	ldrb	fp, [r0, #-1]                                <== NOT EXECUTED
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
   3ca0c:	e089a00a 	add	sl, r9, sl                                    <== NOT EXECUTED
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
   3ca10:	e1a06806 	lsl	r6, r6, #16                                   <== NOT EXECUTED
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
   3ca14:	e0887007 	add	r7, r8, r7                                    <== NOT EXECUTED
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
   3ca18:	e5509008 	ldrb	r9, [r0, #-8]                                <== NOT EXECUTED
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
   3ca1c:	e08aac05 	add	sl, sl, r5, lsl #24                           <== NOT EXECUTED
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
   3ca20:	e0864404 	add	r4, r6, r4, lsl #8                            <== NOT EXECUTED
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
   3ca24:	e0877c0b 	add	r7, r7, fp, lsl #24                           <== NOT EXECUTED
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
   3ca28:	e5505005 	ldrb	r5, [r0, #-5]                                <== NOT EXECUTED
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
      c += ((uint32_t)k[11])<<24;                                     
   3ca2c:	e0873003 	add	r3, r7, r3                                    <== NOT EXECUTED
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
   3ca30:	e08ac00c 	add	ip, sl, ip                                    <== NOT EXECUTED
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
   3ca34:	e0844009 	add	r4, r4, r9                                    <== NOT EXECUTED
      b += ((uint32_t)k[6])<<16;                                      
   3ca38:	e0844c05 	add	r4, r4, r5, lsl #24                           <== NOT EXECUTED
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
      c += ((uint32_t)k[11])<<24;                                     
      mix(a,b,c);                                                     
   3ca3c:	e063c00c 	rsb	ip, r3, ip                                    <== NOT EXECUTED
   3ca40:	e02cce63 	eor	ip, ip, r3, ror #28                           <== NOT EXECUTED
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
   3ca44:	e0842002 	add	r2, r4, r2                                    <== NOT EXECUTED
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
      c += ((uint32_t)k[11])<<24;                                     
      mix(a,b,c);                                                     
   3ca48:	e06c6002 	rsb	r6, ip, r2                                    <== NOT EXECUTED
   3ca4c:	e0266d6c 	eor	r6, r6, ip, ror #26                           <== NOT EXECUTED
   3ca50:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
   3ca54:	e0664003 	rsb	r4, r6, r3                                    <== NOT EXECUTED
   3ca58:	e0244c66 	eor	r4, r4, r6, ror #24                           <== NOT EXECUTED
   3ca5c:	e08c3003 	add	r3, ip, r3                                    <== NOT EXECUTED
   3ca60:	e064c003 	rsb	ip, r4, r3                                    <== NOT EXECUTED
   3ca64:	e02cc864 	eor	ip, ip, r4, ror #16                           <== NOT EXECUTED
   3ca68:	e0866003 	add	r6, r6, r3                                    <== NOT EXECUTED
   3ca6c:	e06c2006 	rsb	r2, ip, r6                                    <== NOT EXECUTED
   3ca70:	e02226ec 	eor	r2, r2, ip, ror #13                           <== NOT EXECUTED
   3ca74:	e0844006 	add	r4, r4, r6                                    <== NOT EXECUTED
   3ca78:	e08cc004 	add	ip, ip, r4                                    <== NOT EXECUTED
   3ca7c:	e0624004 	rsb	r4, r2, r4                                    <== NOT EXECUTED
   3ca80:	e0243e62 	eor	r3, r4, r2, ror #28                           <== NOT EXECUTED
      length -= 12;                                                   
   3ca84:	e241100c 	sub	r1, r1, #12                                   <== NOT EXECUTED
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
      c += ((uint32_t)k[11])<<24;                                     
      mix(a,b,c);                                                     
   3ca88:	e082200c 	add	r2, r2, ip                                    <== NOT EXECUTED
                                                                      
  } else {                        /* need to read the key one byte at a time */
    const uint8_t *k = (const uint8_t *)key;                          
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
   3ca8c:	e351000c 	cmp	r1, #12                                       <== NOT EXECUTED
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
      c += ((uint32_t)k[11])<<24;                                     
      mix(a,b,c);                                                     
      length -= 12;                                                   
   3ca90:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   3ca94:	e280000c 	add	r0, r0, #12                                   <== NOT EXECUTED
                                                                      
  } else {                        /* need to read the key one byte at a time */
    const uint8_t *k = (const uint8_t *)key;                          
                                                                      
    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
    while (length > 12)                                               
   3ca98:	8affffcd 	bhi	3c9d4 <rtems_rfs_dir_hash+0x18>               <== NOT EXECUTED
      length -= 12;                                                   
      k += 12;                                                        
    }                                                                 
                                                                      
    /*-------------------------------- last block: affect all 32 bits of (c) */
    switch(length)                   /* all the case statements fall through */
   3ca9c:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
   3caa0:	e351000b 	cmp	r1, #11                                       <== NOT EXECUTED
   3caa4:	979ff101 	ldrls	pc, [pc, r1, lsl #2]                        <== NOT EXECUTED
   3caa8:	ea000031 	b	3cb74 <rtems_rfs_dir_hash+0x1b8>                <== NOT EXECUTED
   3caac:	0003cb34 	.word	0x0003cb34                                  <== NOT EXECUTED
   3cab0:	0003cb2c 	.word	0x0003cb2c                                  <== NOT EXECUTED
   3cab4:	0003cb24 	.word	0x0003cb24                                  <== NOT EXECUTED
   3cab8:	0003cb1c 	.word	0x0003cb1c                                  <== NOT EXECUTED
   3cabc:	0003cb14 	.word	0x0003cb14                                  <== NOT EXECUTED
   3cac0:	0003cb0c 	.word	0x0003cb0c                                  <== NOT EXECUTED
   3cac4:	0003cb04 	.word	0x0003cb04                                  <== NOT EXECUTED
   3cac8:	0003cafc 	.word	0x0003cafc                                  <== NOT EXECUTED
   3cacc:	0003caf4 	.word	0x0003caf4                                  <== NOT EXECUTED
   3cad0:	0003caec 	.word	0x0003caec                                  <== NOT EXECUTED
   3cad4:	0003cae4 	.word	0x0003cae4                                  <== NOT EXECUTED
   3cad8:	0003cadc 	.word	0x0003cadc                                  <== NOT EXECUTED
    {                                                                 
      case 12: c+=((uint32_t)k[11])<<24;                              
   3cadc:	e5d4100b 	ldrb	r1, [r4, #11]                                <== NOT EXECUTED
   3cae0:	e0833c01 	add	r3, r3, r1, lsl #24                           <== NOT EXECUTED
      case 11: c+=((uint32_t)k[10])<<16;                              
   3cae4:	e5d4100a 	ldrb	r1, [r4, #10]                                <== NOT EXECUTED
   3cae8:	e0833801 	add	r3, r3, r1, lsl #16                           <== NOT EXECUTED
      case 10: c+=((uint32_t)k[9])<<8;                                
   3caec:	e5d41009 	ldrb	r1, [r4, #9]                                 <== NOT EXECUTED
   3caf0:	e0833401 	add	r3, r3, r1, lsl #8                            <== NOT EXECUTED
      case 9 : c+=k[8];                                               
   3caf4:	e5d41008 	ldrb	r1, [r4, #8]                                 <== NOT EXECUTED
   3caf8:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
      case 8 : b+=((uint32_t)k[7])<<24;                               
   3cafc:	e5d41007 	ldrb	r1, [r4, #7]                                 <== NOT EXECUTED
   3cb00:	e0822c01 	add	r2, r2, r1, lsl #24                           <== NOT EXECUTED
      case 7 : b+=((uint32_t)k[6])<<16;                               
   3cb04:	e5d41006 	ldrb	r1, [r4, #6]                                 <== NOT EXECUTED
   3cb08:	e0822801 	add	r2, r2, r1, lsl #16                           <== NOT EXECUTED
      case 6 : b+=((uint32_t)k[5])<<8;                                
   3cb0c:	e5d41005 	ldrb	r1, [r4, #5]                                 <== NOT EXECUTED
   3cb10:	e0822401 	add	r2, r2, r1, lsl #8                            <== NOT EXECUTED
      case 5 : b+=k[4];                                               
   3cb14:	e5d41004 	ldrb	r1, [r4, #4]                                 <== NOT EXECUTED
   3cb18:	e0822001 	add	r2, r2, r1                                    <== NOT EXECUTED
      case 4 : a+=((uint32_t)k[3])<<24;                               
   3cb1c:	e5d41003 	ldrb	r1, [r4, #3]                                 <== NOT EXECUTED
   3cb20:	e08ccc01 	add	ip, ip, r1, lsl #24                           <== NOT EXECUTED
      case 3 : a+=((uint32_t)k[2])<<16;                               
   3cb24:	e5d41002 	ldrb	r1, [r4, #2]                                 <== NOT EXECUTED
   3cb28:	e08cc801 	add	ip, ip, r1, lsl #16                           <== NOT EXECUTED
      case 2 : a+=((uint32_t)k[1])<<8;                                
   3cb2c:	e5d41001 	ldrb	r1, [r4, #1]                                 <== NOT EXECUTED
   3cb30:	e08cc401 	add	ip, ip, r1, lsl #8                            <== NOT EXECUTED
      case 1 : a+=k[0];                                               
   3cb34:	e5d41000 	ldrb	r1, [r4]                                     <== NOT EXECUTED
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
   3cb38:	e0233002 	eor	r3, r3, r2                                    <== NOT EXECUTED
      case 6 : b+=((uint32_t)k[5])<<8;                                
      case 5 : b+=k[4];                                               
      case 4 : a+=((uint32_t)k[3])<<24;                               
      case 3 : a+=((uint32_t)k[2])<<16;                               
      case 2 : a+=((uint32_t)k[1])<<8;                                
      case 1 : a+=k[0];                                               
   3cb3c:	e08cc001 	add	ip, ip, r1                                    <== NOT EXECUTED
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
   3cb40:	e0431962 	sub	r1, r3, r2, ror #18                           <== NOT EXECUTED
   3cb44:	e021c00c 	eor	ip, r1, ip                                    <== NOT EXECUTED
   3cb48:	e04ccae1 	sub	ip, ip, r1, ror #21                           <== NOT EXECUTED
   3cb4c:	e02c2002 	eor	r2, ip, r2                                    <== NOT EXECUTED
   3cb50:	e04223ec 	sub	r2, r2, ip, ror #7                            <== NOT EXECUTED
   3cb54:	e0221001 	eor	r1, r2, r1                                    <== NOT EXECUTED
   3cb58:	e0411862 	sub	r1, r1, r2, ror #16                           <== NOT EXECUTED
   3cb5c:	e021c00c 	eor	ip, r1, ip                                    <== NOT EXECUTED
   3cb60:	e04cce61 	sub	ip, ip, r1, ror #28                           <== NOT EXECUTED
   3cb64:	e02c2002 	eor	r2, ip, r2                                    <== NOT EXECUTED
   3cb68:	e042296c 	sub	r2, r2, ip, ror #18                           <== NOT EXECUTED
   3cb6c:	e0223001 	eor	r3, r2, r1                                    <== NOT EXECUTED
   3cb70:	e0433462 	sub	r3, r3, r2, ror #8                            <== NOT EXECUTED
  return c;                                                           
}                                                                     
   3cb74:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   3cb78:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00035238 <rtems_rfs_dir_lookup_ino>: rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) {
   35238:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   3523c:	e24dd068 	sub	sp, sp, #104	; 0x68                           <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
   35240:	e59dc08c 	ldr	ip, [sp, #140]	; 0x8c                         <== NOT EXECUTED
                          rtems_rfs_inode_handle* inode,              
                          const char*             name,               
                          int                     length,             
                          rtems_rfs_ino*          ino,                
                          uint32_t*               offset)             
{                                                                     
   35244:	e1a09002 	mov	r9, r2                                        <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
  *offset = 0;                                                        
   35248:	e59d2090 	ldr	r2, [sp, #144]	; 0x90                         <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
   3524c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
  *offset = 0;                                                        
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
   35250:	e28d7008 	add	r7, sp, #8                                    <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
   35254:	e58c6000 	str	r6, [ip]                                      <== NOT EXECUTED
  *offset = 0;                                                        
   35258:	e5826000 	str	r6, [r2]                                      <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
   3525c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                          rtems_rfs_inode_handle* inode,              
                          const char*             name,               
                          int                     length,             
                          rtems_rfs_ino*          ino,                
                          uint32_t*               offset)             
{                                                                     
   35260:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
   35264:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
  *offset = 0;                                                        
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
   35268:	ebfffc0c 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
  if (rc > 0)                                                         
   3526c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   35270:	ca00007e 	bgt	35470 <rtems_rfs_dir_lookup_ino+0x238>        <== NOT EXECUTED
    uint32_t           hash;                                          
                                                                      
    /*                                                                
     * Calculate the hash of the look up string.                      
     */                                                               
    hash = rtems_rfs_dir_hash (name, length);                         
   35274:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   35278:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   3527c:	e58d6060 	str	r6, [sp, #96]	; 0x60                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   35280:	e5cd6058 	strb	r6, [sp, #88]	; 0x58                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   35284:	e58d605c 	str	r6, [sp, #92]	; 0x5c                          <== NOT EXECUTED
   35288:	eb001dcb 	bl	3c9bc <rtems_rfs_dir_hash>                     <== NOT EXECUTED
                                                                      
    /*                                                                
     * Locate the first block. The map points to the start after open so just
     * seek 0. If an error the block will be 0.                       
     */                                                               
    rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);              
   3528c:	e28d6064 	add	r6, sp, #100	; 0x64                           <== NOT EXECUTED
    uint32_t           hash;                                          
                                                                      
    /*                                                                
     * Calculate the hash of the look up string.                      
     */                                                               
    hash = rtems_rfs_dir_hash (name, length);                         
   35290:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * Locate the first block. The map points to the start after open so just
     * seek 0. If an error the block will be 0.                       
     */                                                               
    rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);              
   35294:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   35298:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3529c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   352a0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   352a4:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
   352a8:	ebfff962 	bl	33838 <rtems_rfs_block_map_seek>               <== NOT EXECUTED
    if (rc > 0)                                                       
   352ac:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   352b0:	da000060 	ble	35438 <rtems_rfs_dir_lookup_ino+0x200>        <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
        rc = ENOENT;                                                  
      rtems_rfs_buffer_handle_close (fs, &entries);                   
   352b4:	e28d1058 	add	r1, sp, #88	; 0x58                            <== NOT EXECUTED
   352b8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   352bc:	ebfffd89 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
   352c0:	e3540006 	cmp	r4, #6                                        <== NOT EXECUTED
        rc = ENOENT;                                                  
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
   352c4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   352c8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
   352cc:	03a04002 	moveq	r4, #2                                      <== NOT EXECUTED
   352d0:	ea000065 	b	3546c <rtems_rfs_dir_lookup_ino+0x234>          <== NOT EXECUTED
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
        printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
                rtems_rfs_inode_ino (inode), map.bpos.bno);           
                                                                      
      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
   352d4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   352d8:	e28d1058 	add	r1, sp, #88	; 0x58                            <== NOT EXECUTED
   352dc:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   352e0:	ebfffcfe 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
      if (rc > 0)                                                     
   352e4:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   352e8:	ca000059 	bgt	35454 <rtems_rfs_dir_lookup_ino+0x21c>        <== NOT EXECUTED
      /*                                                              
       * Search the block to see if the name matches. A hash of 0xffff or 0x0
       * means the entry is empty.                                    
       */                                                             
                                                                      
      entry = rtems_rfs_buffer_data (&entries);                       
   352ec:	e59d3060 	ldr	r3, [sp, #96]	; 0x60                          <== NOT EXECUTED
                                                                      
      map.bpos.boff = 0;                                              
   352f0:	e58d401c 	str	r4, [sp, #28]                                 <== NOT EXECUTED
      /*                                                              
       * Search the block to see if the name matches. A hash of 0xffff or 0x0
       * means the entry is empty.                                    
       */                                                             
                                                                      
      entry = rtems_rfs_buffer_data (&entries);                       
   352f4:	e5936020 	ldr	r6, [r3, #32]                                 <== NOT EXECUTED
   352f8:	e1a07004 	mov	r7, r4                                        <== NOT EXECUTED
                                                                      
      map.bpos.boff = 0;                                              
                                                                      
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   352fc:	ea00003a 	b	353ec <rtems_rfs_dir_lookup_ino+0x1b4>          <== NOT EXECUTED
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35300:	e5d62000 	ldrb	r2, [r6]                                     <== NOT EXECUTED
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
   35304:	e5d60009 	ldrb	r0, [r6, #9]                                 <== NOT EXECUTED
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35308:	e5d63003 	ldrb	r3, [r6, #3]                                 <== NOT EXECUTED
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
   3530c:	e5d64008 	ldrb	r4, [r6, #8]                                 <== NOT EXECUTED
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35310:	e5d61001 	ldrb	r1, [r6, #1]                                 <== NOT EXECUTED
   35314:	e1833c02 	orr	r3, r3, r2, lsl #24                           <== NOT EXECUTED
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
   35318:	e1804404 	orr	r4, r0, r4, lsl #8                            <== NOT EXECUTED
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
   3531c:	e5d60005 	ldrb	r0, [r6, #5]                                 <== NOT EXECUTED
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35320:	e1833801 	orr	r3, r3, r1, lsl #16                           <== NOT EXECUTED
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
   35324:	e5d61004 	ldrb	r1, [r6, #4]                                 <== NOT EXECUTED
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35328:	e5d62002 	ldrb	r2, [r6, #2]                                 <== NOT EXECUTED
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
   3532c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
   35330:	e1800c01 	orr	r0, r0, r1, lsl #24                           <== NOT EXECUTED
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
   35334:	e5d61007 	ldrb	r1, [r6, #7]                                 <== NOT EXECUTED
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35338:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
   3533c:	e5d62006 	ldrb	r2, [r6, #6]                                 <== NOT EXECUTED
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
   35340:	e1801001 	orr	r1, r0, r1                                    <== NOT EXECUTED
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
   35344:	e59fc138 	ldr	ip, [pc, #312]	; 35484 <rtems_rfs_dir_lookup_ino+0x24c><== NOT EXECUTED
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
   35348:	e1812402 	orr	r2, r1, r2, lsl #8                            <== NOT EXECUTED
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   3534c:	e59d108c 	ldr	r1, [sp, #140]	; 0x8c                         <== NOT EXECUTED
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
   35350:	e154000c 	cmp	r4, ip                                        <== NOT EXECUTED
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
   35354:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
   35358:	0a000028 	beq	35400 <rtems_rfs_dir_lookup_ino+0x1c8>        <== NOT EXECUTED
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
   3535c:	e354000a 	cmp	r4, #10                                       <== NOT EXECUTED
   35360:	da000031 	ble	3542c <rtems_rfs_dir_lookup_ino+0x1f4>        <== NOT EXECUTED
   35364:	e5951018 	ldr	r1, [r5, #24]                                 <== NOT EXECUTED
   35368:	e1540001 	cmp	r4, r1                                        <== NOT EXECUTED
   3536c:	2a00002e 	bcs	3542c <rtems_rfs_dir_lookup_ino+0x1f4>        <== NOT EXECUTED
   35370:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   35374:	0a00002c 	beq	3542c <rtems_rfs_dir_lookup_ino+0x1f4>        <== NOT EXECUTED
   35378:	e5951010 	ldr	r1, [r5, #16]                                 <== NOT EXECUTED
   3537c:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   35380:	8a000029 	bhi	3542c <rtems_rfs_dir_lookup_ino+0x1f4>        <== NOT EXECUTED
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
   35384:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   35388:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   3538c:	1a000012 	bne	353dc <rtems_rfs_dir_lookup_ino+0x1a4>        <== NOT EXECUTED
                    "checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
                    " length:%d ino:%" PRId32 "\n",                   
                    rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
                    elength, rtems_rfs_dir_entry_ino (entry));        
                                                                      
          if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
   35390:	e286000a 	add	r0, r6, #10                                   <== NOT EXECUTED
   35394:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   35398:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   3539c:	eb002b5d 	bl	40118 <memcmp>                                 <== NOT EXECUTED
   353a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   353a4:	1a00000c 	bne	353dc <rtems_rfs_dir_lookup_ino+0x1a4>        <== NOT EXECUTED
          {                                                           
            *offset = rtems_rfs_block_map_pos (fs, &map);             
   353a8:	e28d6008 	add	r6, sp, #8                                    <== NOT EXECUTED
   353ac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   353b0:	e2861010 	add	r1, r6, #16                                   <== NOT EXECUTED
   353b4:	ebfff874 	bl	3358c <rtems_rfs_block_get_pos>                <== NOT EXECUTED
   353b8:	e59dc090 	ldr	ip, [sp, #144]	; 0x90                         <== NOT EXECUTED
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
              printf ("rtems-rfs: dir-lookup-ino: "                   
                      "entry found in ino %" PRIu32 ", ino=%" PRIu32 " offset=%" PRIu32 "\n",
                      rtems_rfs_inode_ino (inode), *ino, *offset);    
                                                                      
            rtems_rfs_buffer_handle_close (fs, &entries);             
   353bc:	e28d1058 	add	r1, sp, #88	; 0x58                            <== NOT EXECUTED
                    rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
                    elength, rtems_rfs_dir_entry_ino (entry));        
                                                                      
          if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
          {                                                           
            *offset = rtems_rfs_block_map_pos (fs, &map);             
   353c0:	e58c0000 	str	r0, [ip]                                      <== NOT EXECUTED
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
              printf ("rtems-rfs: dir-lookup-ino: "                   
                      "entry found in ino %" PRIu32 ", ino=%" PRIu32 " offset=%" PRIu32 "\n",
                      rtems_rfs_inode_ino (inode), *ino, *offset);    
                                                                      
            rtems_rfs_buffer_handle_close (fs, &entries);             
   353c4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   353c8:	ebfffd46 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
   353cc:	e1a04007 	mov	r4, r7                                        <== NOT EXECUTED
            rtems_rfs_block_map_close (fs, &map);                     
   353d0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   353d4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   353d8:	ea000023 	b	3546c <rtems_rfs_dir_lookup_ino+0x234>          <== NOT EXECUTED
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
   353dc:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   353e0:	e0833004 	add	r3, r3, r4                                    <== NOT EXECUTED
   353e4:	e58d301c 	str	r3, [sp, #28]                                 <== NOT EXECUTED
        entry += elength;                                             
   353e8:	e0866004 	add	r6, r6, r4                                    <== NOT EXECUTED
                                                                      
      entry = rtems_rfs_buffer_data (&entries);                       
                                                                      
      map.bpos.boff = 0;                                              
                                                                      
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
   353ec:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
   353f0:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
   353f4:	e243300a 	sub	r3, r3, #10                                   <== NOT EXECUTED
   353f8:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   353fc:	3affffbf 	bcc	35300 <rtems_rfs_dir_lookup_ino+0xc8>         <== NOT EXECUTED
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
   35400:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   35404:	1a000009 	bne	35430 <rtems_rfs_dir_lookup_ino+0x1f8>        <== NOT EXECUTED
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
   35408:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3540c:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   35410:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   35414:	ebfff8fc 	bl	3380c <rtems_rfs_block_map_next_block>         <== NOT EXECUTED
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
                    "block map next block failed in ino %" PRIu32 ": %d: %s\n",
                    rtems_rfs_inode_ino (inode), rc, strerror (rc));  
        }                                                             
        if (rc == ENXIO)                                              
   35418:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
   3541c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
                    "block map next block failed in ino %" PRIu32 ": %d: %s\n",
                    rtems_rfs_inode_ino (inode), rc, strerror (rc));  
        }                                                             
        if (rc == ENXIO)                                              
   35420:	1a000005 	bne	3543c <rtems_rfs_dir_lookup_ino+0x204>        <== NOT EXECUTED
   35424:	e3a04002 	mov	r4, #2                                        <== NOT EXECUTED
   35428:	ea00000a 	b	35458 <rtems_rfs_dir_lookup_ino+0x220>          <== NOT EXECUTED
   3542c:	e3a0a005 	mov	sl, #5                                        <== NOT EXECUTED
   35430:	e1a0400a 	mov	r4, sl                                        <== NOT EXECUTED
   35434:	ea000000 	b	3543c <rtems_rfs_dir_lookup_ino+0x204>          <== NOT EXECUTED
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
   35438:	e1a0b006 	mov	fp, r6                                        <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
   3543c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   35440:	1a000004 	bne	35458 <rtems_rfs_dir_lookup_ino+0x220>        <== NOT EXECUTED
   35444:	e59d2064 	ldr	r2, [sp, #100]	; 0x64                         <== NOT EXECUTED
   35448:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   3544c:	1affffa0 	bne	352d4 <rtems_rfs_dir_lookup_ino+0x9c>         <== NOT EXECUTED
   35450:	ea000009 	b	3547c <rtems_rfs_dir_lookup_ino+0x244>          <== NOT EXECUTED
   35454:	e1a0400a 	mov	r4, sl                                        <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
                rtems_rfs_inode_ino (inode), rc, strerror (rc));      
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
   35458:	e28d1058 	add	r1, sp, #88	; 0x58                            <== NOT EXECUTED
   3545c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   35460:	ebfffd20 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
   35464:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   35468:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   3546c:	ebfffb19 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   35470:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35474:	e28dd068 	add	sp, sp, #104	; 0x68                           <== NOT EXECUTED
   35478:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
        if (rc == ENXIO)                                              
          rc = ENOENT;                                                
      }                                                               
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
   3547c:	e3a04005 	mov	r4, #5                                        <== NOT EXECUTED
   35480:	eafffff4 	b	35458 <rtems_rfs_dir_lookup_ino+0x220>          <== NOT EXECUTED
                                                                      

00034a90 <rtems_rfs_dir_read>: rtems_rfs_dir_read (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_pos_rel offset, struct dirent* dirent, size_t* length) {
   34a90:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   34a94:	e24dd078 	sub	sp, sp, #120	; 0x78                           <== NOT EXECUTED
   34a98:	e59d60a0 	ldr	r6, [sp, #160]	; 0xa0                         <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
    printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
   34a9c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system*  fs,                       
                    rtems_rfs_inode_handle* dir,                      
                    rtems_rfs_pos_rel       offset,                   
                    struct dirent*          dirent,                   
                    size_t*                 length)                   
{                                                                     
   34aa0:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
   34aa4:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                     
    printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
   34aa8:	e586c000 	str	ip, [r6]                                      <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34aac:	e28d2018 	add	r2, sp, #24                                   <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system*  fs,                       
                    rtems_rfs_inode_handle* dir,                      
                    rtems_rfs_pos_rel       offset,                   
                    struct dirent*          dirent,                   
                    size_t*                 length)                   
{                                                                     
   34ab0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   34ab4:	e59d509c 	ldr	r5, [sp, #156]	; 0x9c                         <== NOT EXECUTED
    printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
   34ab8:	ebfffdf8 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34abc:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   34ac0:	ca000099 	bgt	34d2c <rtems_rfs_dir_read+0x29c>              <== NOT EXECUTED
    return rc;                                                        
                                                                      
  if (((rtems_rfs_fs_block_size (fs) -                                
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
   34ac4:	e5947008 	ldr	r7, [r4, #8]                                  <== NOT EXECUTED
   34ac8:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  if (((rtems_rfs_fs_block_size (fs) -                                
   34acc:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   34ad0:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   34ad4:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   34ad8:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   34adc:	eb00839d 	bl	55958 <__moddi3>                               <== NOT EXECUTED
   34ae0:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   34ae4:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   34ae8:	e0522000 	subs	r2, r2, r0                                   <== NOT EXECUTED
   34aec:	e0c33001 	sbc	r3, r3, r1                                    <== NOT EXECUTED
   34af0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   34af4:	ca000010 	bgt	34b3c <rtems_rfs_dir_read+0xac>               <== NOT EXECUTED
   34af8:	1a000001 	bne	34b04 <rtems_rfs_dir_read+0x74>               <== NOT EXECUTED
   34afc:	e352000a 	cmp	r2, #10                                       <== NOT EXECUTED
   34b00:	8a00000d 	bhi	34b3c <rtems_rfs_dir_read+0xac>               <== NOT EXECUTED
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
    offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *         
   34b04:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   34b08:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   34b0c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   34b10:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   34b14:	eb008265 	bl	554b0 <__divdi3>                               <== NOT EXECUTED
   34b18:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   34b1c:	e0922000 	adds	r2, r2, r0                                   <== NOT EXECUTED
   34b20:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   34b24:	e0a33001 	adc	r3, r3, r1                                    <== NOT EXECUTED
   34b28:	e0810792 	umull	r0, r1, r2, r7                              <== NOT EXECUTED
   34b2c:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
   34b30:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
   34b34:	e0211397 	mla	r1, r7, r3, r1                                <== NOT EXECUTED
   34b38:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
              rtems_rfs_fs_block_size (fs));                          
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
   34b3c:	e28d7018 	add	r7, sp, #24                                   <== NOT EXECUTED
   34b40:	e28d8074 	add	r8, sp, #116	; 0x74                           <== NOT EXECUTED
   34b44:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34b48:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   34b4c:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
   34b50:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
   34b54:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
   34b58:	ebfffb36 	bl	33838 <rtems_rfs_block_map_seek>               <== NOT EXECUTED
  if (rc > 0)                                                         
   34b5c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   34b60:	da000004 	ble	34b78 <rtems_rfs_dir_read+0xe8>               <== NOT EXECUTED
  {                                                                   
    if (rc == ENXIO)                                                  
   34b64:	e35a0006 	cmp	sl, #6                                        <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
   34b68:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34b6c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
              rtems_rfs_fs_block_size (fs));                          
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
  if (rc > 0)                                                         
  {                                                                   
    if (rc == ENXIO)                                                  
   34b70:	03a0a002 	moveq	sl, #2                                      <== NOT EXECUTED
   34b74:	ea00006b 	b	34d28 <rtems_rfs_dir_read+0x298>                <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   34b78:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   34b7c:	e58d3070 	str	r3, [sp, #112]	; 0x70                         <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   34b80:	e5cd3068 	strb	r3, [sp, #104]	; 0x68                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   34b84:	e58d306c 	str	r3, [sp, #108]	; 0x6c                         <== NOT EXECUTED
    uint8_t*      entry;                                              
    rtems_rfs_ino eino;                                               
    int           elength;                                            
    int           remaining;                                          
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
   34b88:	e58d5004 	str	r5, [sp, #4]                                  <== NOT EXECUTED
   34b8c:	e28d9068 	add	r9, sp, #104	; 0x68                           <== NOT EXECUTED
   34b90:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   34b94:	e59d2074 	ldr	r2, [sp, #116]	; 0x74                         <== NOT EXECUTED
   34b98:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   34b9c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34ba0:	ebfffece 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
    if (rc > 0)                                                       
   34ba4:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
   34ba8:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   34bac:	e28d2074 	add	r2, sp, #116	; 0x74                           <== NOT EXECUTED
   34bb0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    int           remaining;                                          
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_buffer_handle_close (fs, &buffer);                    
   34bb4:	c1a01009 	movgt	r1, r9                                      <== NOT EXECUTED
   34bb8:	ca000057 	bgt	34d1c <rtems_rfs_dir_read+0x28c>              <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
   34bbc:	e59d3070 	ldr	r3, [sp, #112]	; 0x70                         <== NOT EXECUTED
    entry += map.bpos.boff;                                           
   34bc0:	e59dc02c 	ldr	ip, [sp, #44]	; 0x2c                          <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &buffer);                    
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
   34bc4:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
    entry += map.bpos.boff;                                           
   34bc8:	e083700c 	add	r7, r3, ip                                    <== NOT EXECUTED
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
   34bcc:	e7d3e00c 	ldrb	lr, [r3, ip]                                 <== NOT EXECUTED
   34bd0:	e5d7b003 	ldrb	fp, [r7, #3]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
   34bd4:	e5d73009 	ldrb	r3, [r7, #9]                                 <== NOT EXECUTED
   34bd8:	e5d78008 	ldrb	r8, [r7, #8]                                 <== NOT EXECUTED
    eino    = rtems_rfs_dir_entry_ino (entry);                        
   34bdc:	e5d75001 	ldrb	r5, [r7, #1]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
   34be0:	e1838408 	orr	r8, r3, r8, lsl #8                            <== NOT EXECUTED
    eino    = rtems_rfs_dir_entry_ino (entry);                        
   34be4:	e18b3c0e 	orr	r3, fp, lr, lsl #24                           <== NOT EXECUTED
   34be8:	e1833805 	orr	r3, r3, r5, lsl #16                           <== NOT EXECUTED
   34bec:	e5d7e002 	ldrb	lr, [r7, #2]                                 <== NOT EXECUTED
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
   34bf0:	e59f5140 	ldr	r5, [pc, #320]	; 34d38 <rtems_rfs_dir_read+0x2a8><== NOT EXECUTED
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
   34bf4:	e183340e 	orr	r3, r3, lr, lsl #8                            <== NOT EXECUTED
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
   34bf8:	e1580005 	cmp	r8, r5                                        <== NOT EXECUTED
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
   34bfc:	e287e002 	add	lr, r7, #2                                    <== NOT EXECUTED
   34c00:	e2875003 	add	r5, r7, #3                                    <== NOT EXECUTED
   34c04:	e287b001 	add	fp, r7, #1                                    <== NOT EXECUTED
   34c08:	e58de014 	str	lr, [sp, #20]                                 <== NOT EXECUTED
   34c0c:	e58d5010 	str	r5, [sp, #16]                                 <== NOT EXECUTED
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
   34c10:	0a000031 	beq	34cdc <rtems_rfs_dir_read+0x24c>              <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
   34c14:	e358000a 	cmp	r8, #10                                       <== NOT EXECUTED
   34c18:	e59d5004 	ldr	r5, [sp, #4]                                  <== NOT EXECUTED
   34c1c:	da00003b 	ble	34d10 <rtems_rfs_dir_read+0x280>              <== NOT EXECUTED
   34c20:	e5941018 	ldr	r1, [r4, #24]                                 <== NOT EXECUTED
   34c24:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   34c28:	11580001 	cmpne	r8, r1                                      <== NOT EXECUTED
   34c2c:	33a01000 	movcc	r1, #0                                      <== NOT EXECUTED
   34c30:	23a01001 	movcs	r1, #1                                      <== NOT EXECUTED
   34c34:	2a000035 	bcs	34d10 <rtems_rfs_dir_read+0x280>              <== NOT EXECUTED
   34c38:	e5942010 	ldr	r2, [r4, #16]                                 <== NOT EXECUTED
   34c3c:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   34c40:	8a000032 	bhi	34d10 <rtems_rfs_dir_read+0x280>              <== NOT EXECUTED
                  rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
   34c44:	e3a02e11 	mov	r2, #272	; 0x110                              <== NOT EXECUTED
   34c48:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34c4c:	eb002de2 	bl	403dc <memset>                                 <== NOT EXECUTED
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
                                                                      
      *length += elength;                                             
   34c50:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
   34c54:	e0883003 	add	r3, r8, r3                                    <== NOT EXECUTED
   34c58:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
   34c5c:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   34c60:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
   34c64:	e0622001 	rsb	r2, r2, r1                                    <== NOT EXECUTED
   34c68:	e0682002 	rsb	r2, r8, r2                                    <== NOT EXECUTED
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
   34c6c:	e352000a 	cmp	r2, #10                                       <== NOT EXECUTED
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
   34c70:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   34c74:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
      *length += elength;                                             
                                                                      
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
        *length += remaining;                                         
   34c78:	d0823003 	addle	r3, r2, r3                                  <== NOT EXECUTED
                                                                      
      elength -= RTEMS_RFS_DIR_ENTRY_SIZE;                            
   34c7c:	e248800a 	sub	r8, r8, #10                                   <== NOT EXECUTED
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
   34c80:	e9850003 	stmib	r5, {r0, r1}                                <== NOT EXECUTED
      *length += elength;                                             
                                                                      
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
        *length += remaining;                                         
   34c84:	d5863000 	strle	r3, [r6]                                    <== NOT EXECUTED
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
   34c88:	e3a01e11 	mov	r1, #272	; 0x110                              <== NOT EXECUTED
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
        *length += remaining;                                         
                                                                      
      elength -= RTEMS_RFS_DIR_ENTRY_SIZE;                            
   34c8c:	e35800ff 	cmp	r8, #255	; 0xff                               <== NOT EXECUTED
   34c90:	a3a080ff 	movge	r8, #255	; 0xff                             <== NOT EXECUTED
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
   34c94:	e1c510bc 	strh	r1, [r5, #12]                                <== NOT EXECUTED
                                                                      
      elength -= RTEMS_RFS_DIR_ENTRY_SIZE;                            
      if (elength > NAME_MAX)                                         
        elength = NAME_MAX;                                           
                                                                      
      memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
   34c98:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   34c9c:	e287100a 	add	r1, r7, #10                                   <== NOT EXECUTED
   34ca0:	e2850010 	add	r0, r5, #16                                   <== NOT EXECUTED
   34ca4:	eb002d45 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
   34ca8:	e5db3000 	ldrb	r3, [fp]                                     <== NOT EXECUTED
   34cac:	e59de010 	ldr	lr, [sp, #16]                                 <== NOT EXECUTED
   34cb0:	e5d72000 	ldrb	r2, [r7]                                     <== NOT EXECUTED
   34cb4:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
   34cb8:	e5de1000 	ldrb	r1, [lr]                                     <== NOT EXECUTED
   34cbc:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
   34cc0:	e1833c02 	orr	r3, r3, r2, lsl #24                           <== NOT EXECUTED
   34cc4:	e5d02000 	ldrb	r2, [r0]                                     <== NOT EXECUTED
   34cc8:	e1833001 	orr	r3, r3, r1                                    <== NOT EXECUTED
   34ccc:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
      dirent->d_namlen = elength;                                     
   34cd0:	e1c580be 	strh	r8, [r5, #14]                                <== NOT EXECUTED
      if (elength > NAME_MAX)                                         
        elength = NAME_MAX;                                           
                                                                      
      memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
   34cd4:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
      dirent->d_namlen = elength;                                     
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                 
        printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
                dirent->d_off, dirent->d_ino, dirent->d_name);        
      break;                                                          
   34cd8:	ea00000d 	b	34d14 <rtems_rfs_dir_read+0x284>                <== NOT EXECUTED
    }                                                                 
                                                                      
    *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;          
   34cdc:	e594e008 	ldr	lr, [r4, #8]                                  <== NOT EXECUTED
   34ce0:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
   34ce4:	e06cc00e 	rsb	ip, ip, lr                                    <== NOT EXECUTED
   34ce8:	e083300c 	add	r3, r3, ip                                    <== NOT EXECUTED
   34cec:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
   34cf0:	ebfffac5 	bl	3380c <rtems_rfs_block_map_next_block>         <== NOT EXECUTED
    if (rc == ENXIO)                                                  
   34cf4:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
   34cf8:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    if (rc == ENXIO)                                                  
   34cfc:	03a0a002 	moveq	sl, #2                                      <== NOT EXECUTED
   34d00:	0a000003 	beq	34d14 <rtems_rfs_dir_read+0x284>              <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Look for an empty entry and if this is the last block that is the end of
   * the directory.                                                   
   */                                                                 
  while (rc == 0)                                                     
   34d04:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   34d08:	0affffa0 	beq	34b90 <rtems_rfs_dir_read+0x100>              <== NOT EXECUTED
   34d0c:	ea000000 	b	34d14 <rtems_rfs_dir_read+0x284>                <== NOT EXECUTED
   34d10:	e3a0a005 	mov	sl, #5                                        <== NOT EXECUTED
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
   34d14:	e28d1068 	add	r1, sp, #104	; 0x68                           <== NOT EXECUTED
   34d18:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34d1c:	ebfffef1 	bl	348e8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
   34d20:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   34d24:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
   34d28:	ebfffcea 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   34d2c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   34d30:	e28dd078 	add	sp, sp, #120	; 0x78                           <== NOT EXECUTED
   34d34:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00035b3c <rtems_rfs_file_close>: if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n", handle->shared->inode.ino); if (handle->shared->references > 0)
   35b3c:	e591301c 	ldr	r3, [r1, #28]                                 <== NOT EXECUTED
   35b40:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
   35b44:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    handle->shared->references--;                                     
   35b48:	c2422001 	subgt	r2, r2, #1                                  <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_close (rtems_rfs_file_system* fs,                      
                      rtems_rfs_file_handle* handle)                  
{                                                                     
   35b4c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                   
    printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",        
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
    handle->shared->references--;                                     
   35b50:	c5832008 	strgt	r2, [r3, #8]                                <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_close (rtems_rfs_file_system* fs,                      
                      rtems_rfs_file_handle* handle)                  
{                                                                     
   35b54:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
    handle->shared->references--;                                     
                                                                      
  if (handle->shared->references == 0)                                
   35b58:	e591101c 	ldr	r1, [r1, #28]                                 <== NOT EXECUTED
   35b5c:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
   35b60:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_close (rtems_rfs_file_system* fs,                      
                      rtems_rfs_file_handle* handle)                  
{                                                                     
   35b64:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
    handle->shared->references--;                                     
                                                                      
  if (handle->shared->references == 0)                                
   35b68:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
   35b6c:	1a000054 	bne	35cc4 <rtems_rfs_file_close+0x188>            <== NOT EXECUTED
  {                                                                   
    if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))          
   35b70:	e5913018 	ldr	r3, [r1, #24]                                 <== NOT EXECUTED
   35b74:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   35b78:	1a000003 	bne	35b8c <rtems_rfs_file_close+0x50>             <== NOT EXECUTED
      rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);        
   35b7c:	e281100c 	add	r1, r1, #12                                   <== NOT EXECUTED
   35b80:	eb000769 	bl	3792c <rtems_rfs_inode_load>                   <== NOT EXECUTED
                                                                      
    if (rrc == 0)                                                     
   35b84:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   35b88:	1a000039 	bne	35c74 <rtems_rfs_file_close+0x138>            <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * @todo This could be clever and only update if different.     
       */                                                             
      rtems_rfs_inode_set_atime (&handle->shared->inode,              
   35b8c:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
   35b90:	e592308c 	ldr	r3, [r2, #140]	; 0x8c                         <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          atime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->atime, atime);                  
   35b94:	e5921018 	ldr	r1, [r2, #24]                                 <== NOT EXECUTED
   35b98:	e1a00c23 	lsr	r0, r3, #24                                   <== NOT EXECUTED
   35b9c:	e5c10010 	strb	r0, [r1, #16]                                <== NOT EXECUTED
   35ba0:	e5921018 	ldr	r1, [r2, #24]                                 <== NOT EXECUTED
   35ba4:	e1a00823 	lsr	r0, r3, #16                                   <== NOT EXECUTED
   35ba8:	e5c10011 	strb	r0, [r1, #17]                                <== NOT EXECUTED
   35bac:	e5921018 	ldr	r1, [r2, #24]                                 <== NOT EXECUTED
   35bb0:	e1a00423 	lsr	r0, r3, #8                                    <== NOT EXECUTED
   35bb4:	e5c10012 	strb	r0, [r1, #18]                                <== NOT EXECUTED
   35bb8:	e5921018 	ldr	r1, [r2, #24]                                 <== NOT EXECUTED
   35bbc:	e5c13013 	strb	r3, [r1, #19]                                <== NOT EXECUTED
                                 handle->shared->atime);              
      rtems_rfs_inode_set_mtime (&handle->shared->inode,              
   35bc0:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35bc4:	e5931090 	ldr	r1, [r3, #144]	; 0x90                         <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          mtime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->mtime, mtime);                  
   35bc8:	e593c018 	ldr	ip, [r3, #24]                                 <== NOT EXECUTED
static inline void                                                    
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          atime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->atime, atime);                  
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   35bcc:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          mtime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->mtime, mtime);                  
   35bd0:	e1a0ec21 	lsr	lr, r1, #24                                   <== NOT EXECUTED
static inline void                                                    
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          atime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->atime, atime);                  
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   35bd4:	e5c2001c 	strb	r0, [r2, #28]                                <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          mtime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->mtime, mtime);                  
   35bd8:	e5cce014 	strb	lr, [ip, #20]                                <== NOT EXECUTED
   35bdc:	e5932018 	ldr	r2, [r3, #24]                                 <== NOT EXECUTED
   35be0:	e1a0c821 	lsr	ip, r1, #16                                   <== NOT EXECUTED
   35be4:	e5c2c015 	strb	ip, [r2, #21]                                <== NOT EXECUTED
   35be8:	e5932018 	ldr	r2, [r3, #24]                                 <== NOT EXECUTED
   35bec:	e1a0c421 	lsr	ip, r1, #8                                    <== NOT EXECUTED
   35bf0:	e5c2c016 	strb	ip, [r2, #22]                                <== NOT EXECUTED
   35bf4:	e5932018 	ldr	r2, [r3, #24]                                 <== NOT EXECUTED
   35bf8:	e5c21017 	strb	r1, [r2, #23]                                <== NOT EXECUTED
                                 handle->shared->mtime);              
      rtems_rfs_inode_set_ctime (&handle->shared->inode,              
   35bfc:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
   35c00:	e5921094 	ldr	r1, [r2, #148]	; 0x94                         <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          ctime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->ctime, ctime);                  
   35c04:	e592c018 	ldr	ip, [r2, #24]                                 <== NOT EXECUTED
   35c08:	e1a0ec21 	lsr	lr, r1, #24                                   <== NOT EXECUTED
static inline void                                                    
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          mtime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->mtime, mtime);                  
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   35c0c:	e5c3001c 	strb	r0, [r3, #28]                                <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          ctime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->ctime, ctime);                  
   35c10:	e5cce018 	strb	lr, [ip, #24]                                <== NOT EXECUTED
   35c14:	e5923018 	ldr	r3, [r2, #24]                                 <== NOT EXECUTED
   35c18:	e1a0c821 	lsr	ip, r1, #16                                   <== NOT EXECUTED
   35c1c:	e5c3c019 	strb	ip, [r3, #25]                                <== NOT EXECUTED
   35c20:	e5923018 	ldr	r3, [r2, #24]                                 <== NOT EXECUTED
   35c24:	e1a0c421 	lsr	ip, r1, #8                                    <== NOT EXECUTED
   35c28:	e5c3c01a 	strb	ip, [r3, #26]                                <== NOT EXECUTED
   35c2c:	e5923018 	ldr	r3, [r2, #24]                                 <== NOT EXECUTED
   35c30:	e5c3101b 	strb	r1, [r3, #27]                                <== NOT EXECUTED
                                 handle->shared->ctime);              
      if (!rtems_rfs_block_size_equal (&handle->shared->size,         
   35c34:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35c38:	e5931084 	ldr	r1, [r3, #132]	; 0x84                         <== NOT EXECUTED
   35c3c:	e593c03c 	ldr	ip, [r3, #60]	; 0x3c                          <== NOT EXECUTED
   35c40:	e151000c 	cmp	r1, ip                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   35c44:	e5c2001c 	strb	r0, [r2, #28]                                <== NOT EXECUTED
   35c48:	1a000003 	bne	35c5c <rtems_rfs_file_close+0x120>            <== NOT EXECUTED
   35c4c:	e5930088 	ldr	r0, [r3, #136]	; 0x88                         <== NOT EXECUTED
   35c50:	e5932040 	ldr	r2, [r3, #64]	; 0x40                          <== NOT EXECUTED
   35c54:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
   35c58:	0a000004 	beq	35c70 <rtems_rfs_file_close+0x134>            <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,              
                              rtems_rfs_block_size* size)             
{                                                                     
  rtems_rfs_block_copy_size (&map->size, size);                       
   35c5c:	e5932088 	ldr	r2, [r3, #136]	; 0x88                         <== NOT EXECUTED
  map->dirty = true;                                                  
   35c60:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
   35c64:	e5c30034 	strb	r0, [r3, #52]	; 0x34                         <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,              
                              rtems_rfs_block_size* size)             
{                                                                     
  rtems_rfs_block_copy_size (&map->size, size);                       
   35c68:	e583103c 	str	r1, [r3, #60]	; 0x3c                          <== NOT EXECUTED
   35c6c:	e5832040 	str	r2, [r3, #64]	; 0x40                          <== NOT EXECUTED
  map->dirty = true;                                                  
   35c70:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
                                       &handle->shared->map.size))    
        rtems_rfs_block_map_set_size (&handle->shared->map,           
                                      &handle->shared->size);         
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_close (fs, &handle->shared->map);        
   35c74:	e594101c 	ldr	r1, [r4, #28]                                 <== NOT EXECUTED
   35c78:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35c7c:	e2811034 	add	r1, r1, #52	; 0x34                            <== NOT EXECUTED
   35c80:	ebfff914 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
    if (rc > 0)                                                       
   35c84:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35c88:	da000001 	ble	35c94 <rtems_rfs_file_close+0x158>            <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
        printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
   35c8c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   35c90:	01a05000 	moveq	r5, r0                                      <== NOT EXECUTED
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rc = rtems_rfs_inode_close (fs, &handle->shared->inode);          
   35c94:	e594101c 	ldr	r1, [r4, #28]                                 <== NOT EXECUTED
   35c98:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35c9c:	e281100c 	add	r1, r1, #12                                   <== NOT EXECUTED
   35ca0:	eb000714 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    if (rc > 0)                                                       
   35ca4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35ca8:	da000001 	ble	35cb4 <rtems_rfs_file_close+0x178>            <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
        printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
   35cac:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   35cb0:	01a05000 	moveq	r5, r0                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
   35cb4:	e594001c 	ldr	r0, [r4, #28]                                 <== NOT EXECUTED
   35cb8:	ebff59e0 	bl	c440 <_Chain_Extract>                          <== NOT EXECUTED
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rtems_chain_extract (&handle->shared->link);                      
    free (handle->shared);                                            
   35cbc:	e594001c 	ldr	r0, [r4, #28]                                 <== NOT EXECUTED
   35cc0:	ebff467b 	bl	76b4 <free>                                    <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   35cc4:	e2841004 	add	r1, r4, #4                                    <== NOT EXECUTED
   35cc8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35ccc:	ebfffa3a 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   35cd0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                 
      printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
  }                                                                   
                                                                      
  free (handle);                                                      
   35cd4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   35cd8:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   35cdc:	e5c43004 	strb	r3, [r4, #4]                                 <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   35ce0:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
   35ce4:	ebff4672 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
  return rrc;                                                         
}                                                                     
   35ce8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   35cec:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00035488 <rtems_rfs_file_get_shared>: */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null;
   35488:	e2802074 	add	r2, r0, #116	; 0x74                           <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->first;                                            
   3548c:	e5903070 	ldr	r3, [r0, #112]	; 0x70                         <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,                 
                           rtems_rfs_ino          ino)                
{                                                                     
  rtems_chain_node* node;                                             
  node = rtems_chain_first (&fs->file_shares);                        
  while (!rtems_chain_is_tail (&fs->file_shares, node))               
   35490:	ea000004 	b	354a8 <rtems_rfs_file_get_shared+0x20>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
   35494:	e5930014 	ldr	r0, [r3, #20]                                 <== NOT EXECUTED
   35498:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
  rtems_chain_node* node;                                             
  node = rtems_chain_first (&fs->file_shares);                        
  while (!rtems_chain_is_tail (&fs->file_shares, node))               
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
   3549c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
    if (shared->inode.ino == ino)                                     
   354a0:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
   354a4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,                 
                           rtems_rfs_ino          ino)                
{                                                                     
  rtems_chain_node* node;                                             
  node = rtems_chain_first (&fs->file_shares);                        
  while (!rtems_chain_is_tail (&fs->file_shares, node))               
   354a8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   354ac:	1afffff8 	bne	35494 <rtems_rfs_file_get_shared+0xc>         <== NOT EXECUTED
   354b0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    if (shared->inode.ino == ino)                                     
      return shared;                                                  
    node = rtems_chain_next (node);                                   
  }                                                                   
  return NULL;                                                        
}                                                                     
   354b4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0003599c <rtems_rfs_file_io_end>: int rtems_rfs_file_io_end (rtems_rfs_file_handle* handle, size_t size, bool read) {
   3599c:	e92d45f1 	push	{r0, r4, r5, r6, r7, r8, sl, lr}             <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",               
            read ? "read" : "write", size);                           
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
   359a0:	e590400c 	ldr	r4, [r0, #12]                                 <== NOT EXECUTED
   359a4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,                 
                       size_t                 size,                   
                       bool                   read)                   
{                                                                     
   359a8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   359ac:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
   359b0:	e20260ff 	and	r6, r2, #255	; 0xff                           <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",               
            read ? "read" : "write", size);                           
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
   359b4:	0a000015 	beq	35a10 <rtems_rfs_file_io_end+0x74>            <== NOT EXECUTED
  {                                                                   
    if (!read)                                                        
   359b8:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
      rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));   
   359bc:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
   359c0:	05c03004 	strbeq	r3, [r0, #4]                               <== NOT EXECUTED
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
   359c4:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
   359c8:	e2851004 	add	r1, r5, #4                                    <== NOT EXECUTED
   359cc:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   359d0:	ebfffaf9 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
                                          rtems_rfs_file_buffer (handle));
    if (rc > 0)                                                       
   359d4:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   359d8:	da00000c 	ble	35a10 <rtems_rfs_file_io_end+0x74>            <== NOT EXECUTED
    {                                                                 
      printf (                                                        
   359dc:	e59f314c 	ldr	r3, [pc, #332]	; 35b30 <rtems_rfs_file_io_end+0x194><== NOT EXECUTED
   359e0:	e59f214c 	ldr	r2, [pc, #332]	; 35b34 <rtems_rfs_file_io_end+0x198><== NOT EXECUTED
   359e4:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   359e8:	11a06002 	movne	r6, r2                                      <== NOT EXECUTED
   359ec:	01a06003 	moveq	r6, r3                                      <== NOT EXECUTED
   359f0:	eb0036b3 	bl	434c4 <strerror>                               <== NOT EXECUTED
   359f4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   359f8:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   359fc:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   35a00:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   35a04:	e59f012c 	ldr	r0, [pc, #300]	; 35b38 <rtems_rfs_file_io_end+0x19c><== NOT EXECUTED
   35a08:	eb002e9a 	bl	41478 <printf>                                 <== NOT EXECUTED
        "rtems-rfs: file-io:   end: error on release: %s size=%zu: %d: %s\n",
        read ? "read" : "write", size, rc, strerror (rc));            
                                                                      
      return rc;                                                      
   35a0c:	ea000045 	b	35b28 <rtems_rfs_file_io_end+0x18c>             <== NOT EXECUTED
   * increase the block number and adjust the offset.                 
   *                                                                  
   * If we are the last block and the position is past the current size update
   * the size with the new length. The map holds the block count.     
   */                                                                 
  handle->bpos.boff += size;                                          
   35a10:	e5952014 	ldr	r2, [r5, #20]                                 <== NOT EXECUTED
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
   35a14:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
   * increase the block number and adjust the offset.                 
   *                                                                  
   * If we are the last block and the position is past the current size update
   * the size with the new length. The map holds the block count.     
   */                                                                 
  handle->bpos.boff += size;                                          
   35a18:	e0877002 	add	r7, r7, r2                                    <== NOT EXECUTED
   35a1c:	e5857014 	str	r7, [r5, #20]                                 <== NOT EXECUTED
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
   35a20:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   35a24:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
   35a28:	e1570002 	cmp	r7, r2                                        <== NOT EXECUTED
   35a2c:	3a000005 	bcc	35a48 <rtems_rfs_file_io_end+0xac>            <== NOT EXECUTED
  {                                                                   
    handle->bpos.bno++;                                               
   35a30:	e5952010 	ldr	r2, [r5, #16]                                 <== NOT EXECUTED
   35a34:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   35a38:	e5852010 	str	r2, [r5, #16]                                 <== NOT EXECUTED
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
   35a3c:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
   35a40:	e0637007 	rsb	r7, r3, r7                                    <== NOT EXECUTED
   35a44:	e5857014 	str	r7, [r5, #20]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
   35a48:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   35a4c:	1a000018 	bne	35ab4 <rtems_rfs_file_io_end+0x118>           <== NOT EXECUTED
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
   35a50:	e5953010 	ldr	r3, [r5, #16]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
   35a54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   35a58:	0a000003 	beq	35a6c <rtems_rfs_file_io_end+0xd0>            <== NOT EXECUTED
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
   35a5c:	e595201c 	ldr	r2, [r5, #28]                                 <== NOT EXECUTED
   35a60:	e592203c 	ldr	r2, [r2, #60]	; 0x3c                          <== NOT EXECUTED
   35a64:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   35a68:	0a00000a 	beq	35a98 <rtems_rfs_file_io_end+0xfc>            <== NOT EXECUTED
   35a6c:	e595201c 	ldr	r2, [r5, #28]                                 <== NOT EXECUTED
   35a70:	e592103c 	ldr	r1, [r2, #60]	; 0x3c                          <== NOT EXECUTED
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
   35a74:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   35a78:	2a000006 	bcs	35a98 <rtems_rfs_file_io_end+0xfc>            <== NOT EXECUTED
   35a7c:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
   35a80:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   35a84:	1a00000a 	bne	35ab4 <rtems_rfs_file_io_end+0x118>           <== NOT EXECUTED
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
   35a88:	e5923040 	ldr	r3, [r2, #64]	; 0x40                          <== NOT EXECUTED
   35a8c:	e5952014 	ldr	r2, [r5, #20]                                 <== NOT EXECUTED
   35a90:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   35a94:	9a000006 	bls	35ab4 <rtems_rfs_file_io_end+0x118>           <== NOT EXECUTED
                                    rtems_rfs_file_bpos (handle)))    
  {                                                                   
    rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle), 
   35a98:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
   35a9c:	e5951014 	ldr	r1, [r5, #20]                                 <== NOT EXECUTED
  map->dirty = true;                                                  
   35aa0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   35aa4:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
   35aa8:	e5831040 	str	r1, [r3, #64]	; 0x40                          <== NOT EXECUTED
  map->dirty = true;                                                  
   35aac:	e5c32034 	strb	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
   35ab0:	ea000000 	b	35ab8 <rtems_rfs_file_io_end+0x11c>             <== NOT EXECUTED
   35ab4:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
   35ab8:	e595a000 	ldr	sl, [r5]                                      <== NOT EXECUTED
   35abc:	e1a07008 	mov	r7, r8                                        <== NOT EXECUTED
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
   35ac0:	e31a0002 	tst	sl, #2                                        <== NOT EXECUTED
   35ac4:	13a07000 	movne	r7, #0                                      <== NOT EXECUTED
  length = rtems_rfs_file_update_length (handle) && length;           
   35ac8:	e31a0004 	tst	sl, #4                                        <== NOT EXECUTED
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
   35acc:	e22aa001 	eor	sl, sl, #1                                    <== NOT EXECUTED
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
  length = rtems_rfs_file_update_length (handle) && length;           
   35ad0:	13a08000 	movne	r8, #0                                      <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io:   end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
            handle->bpos.bno, handle->bpos.boff,                      
            atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
                                                                      
  if (atime || mtime)                                                 
   35ad4:	e21aa001 	ands	sl, sl, #1                                   <== NOT EXECUTED
   35ad8:	1a000001 	bne	35ae4 <rtems_rfs_file_io_end+0x148>           <== NOT EXECUTED
   35adc:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   35ae0:	0a00000a 	beq	35b10 <rtems_rfs_file_io_end+0x174>           <== NOT EXECUTED
  {                                                                   
    time_t now = time (NULL);                                         
   35ae4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   35ae8:	eb004c76 	bl	48cc8 <time>                                   <== NOT EXECUTED
    if (read && atime)                                                
   35aec:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   35af0:	0a000003 	beq	35b04 <rtems_rfs_file_io_end+0x168>           <== NOT EXECUTED
   35af4:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
      handle->shared->atime = now;                                    
   35af8:	1595301c 	ldrne	r3, [r5, #28]                               <== NOT EXECUTED
   35afc:	1583008c 	strne	r0, [r3, #140]	; 0x8c                       <== NOT EXECUTED
   35b00:	ea000002 	b	35b10 <rtems_rfs_file_io_end+0x174>             <== NOT EXECUTED
    if (!read && mtime)                                               
   35b04:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
      handle->shared->mtime = now;                                    
   35b08:	1595301c 	ldrne	r3, [r5, #28]                               <== NOT EXECUTED
   35b0c:	15830090 	strne	r0, [r3, #144]	; 0x90                       <== NOT EXECUTED
  }                                                                   
  if (length)                                                         
   35b10:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
  {                                                                   
    handle->shared->size.count =                                      
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
   35b14:	1595301c 	ldrne	r3, [r5, #28]                               <== NOT EXECUTED
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
   35b18:	1593203c 	ldrne	r2, [r3, #60]	; 0x3c                        <== NOT EXECUTED
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
   35b1c:	15931040 	ldrne	r1, [r3, #64]	; 0x40                        <== NOT EXECUTED
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
   35b20:	15832084 	strne	r2, [r3, #132]	; 0x84                       <== NOT EXECUTED
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
   35b24:	15831088 	strne	r1, [r3, #136]	; 0x88                       <== NOT EXECUTED
      rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));  
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   35b28:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35b2c:	e8bd85f8 	pop	{r3, r4, r5, r6, r7, r8, sl, pc}              <== NOT EXECUTED
                                                                      

000355f4 <rtems_rfs_file_io_release>: return rc; } int rtems_rfs_file_io_release (rtems_rfs_file_handle* handle) {
   355f4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  int rc = 0;                                                         
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
   355f8:	e590000c 	ldr	r0, [r0, #12]                                 <== NOT EXECUTED
   355fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35600:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
   35604:	e591301c 	ldr	r3, [r1, #28]                                 <== NOT EXECUTED
   35608:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   3560c:	e2811004 	add	r1, r1, #4                                    <== NOT EXECUTED
   35610:	eafffbe9 	b	345bc <rtems_rfs_buffer_handle_release>         <== NOT EXECUTED
                                                                      

000354b8 <rtems_rfs_file_io_start>: int rtems_rfs_file_io_start (rtems_rfs_file_handle* handle, size_t* available, bool read) {
   354b8:	e92d41f1 	push	{r0, r4, r5, r6, r7, r8, lr}                 <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
            read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
                                                                      
  if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))           
   354bc:	e590700c 	ldr	r7, [r0, #12]                                 <== NOT EXECUTED
   354c0:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,               
                         size_t*                available,            
                         bool                   read)                 
{                                                                     
   354c4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   354c8:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   354cc:	e20250ff 	and	r5, r2, #255	; 0xff                           <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
            read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
                                                                      
  if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))           
   354d0:	1a00002f 	bne	35594 <rtems_rfs_file_io_start+0xdc>          <== NOT EXECUTED
    bool                   request_read;                              
    int                    rc;                                        
                                                                      
    request_read = read;                                              
                                                                      
    rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),        
   354d4:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
   354d8:	e2842010 	add	r2, r4, #16                                   <== NOT EXECUTED
   354dc:	e2831034 	add	r1, r3, #52	; 0x34                            <== NOT EXECUTED
   354e0:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   354e4:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   354e8:	ebfff871 	bl	336b4 <rtems_rfs_block_map_find>               <== NOT EXECUTED
                                   rtems_rfs_file_map (handle),       
                                   rtems_rfs_file_bpos (handle),      
                                   &block);                           
    if (rc > 0)                                                       
   354ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    bool                   request_read;                              
    int                    rc;                                        
                                                                      
    request_read = read;                                              
                                                                      
    rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),        
   354f0:	e1a0800d 	mov	r8, sp                                        <== NOT EXECUTED
                                   rtems_rfs_file_map (handle),       
                                   rtems_rfs_file_bpos (handle),      
                                   &block);                           
    if (rc > 0)                                                       
   354f4:	da000010 	ble	3553c <rtems_rfs_file_io_start+0x84>          <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * Has the read reached the EOF ?                               
       */                                                             
      if (read && (rc == ENXIO))                                      
   354f8:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   354fc:	0a000003 	beq	35510 <rtems_rfs_file_io_start+0x58>          <== NOT EXECUTED
   35500:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
      {                                                               
        *available = 0;                                               
   35504:	05867000 	streq	r7, [r6]                                    <== NOT EXECUTED
   35508:	01a00007 	moveq	r0, r7                                      <== NOT EXECUTED
   3550c:	ea000037 	b	355f0 <rtems_rfs_file_io_start+0x138>           <== NOT EXECUTED
        return 0;                                                     
      }                                                               
                                                                      
      if (rc != ENXIO)                                                
   35510:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
   35514:	1a000035 	bne	355f0 <rtems_rfs_file_io_start+0x138>         <== NOT EXECUTED
        return rc;                                                    
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                  
        printf ("rtems-rfs: file-io: start: grow\n");                 
                                                                      
      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),      
   35518:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
   3551c:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   35520:	e2821034 	add	r1, r2, #52	; 0x34                            <== NOT EXECUTED
   35524:	e5920098 	ldr	r0, [r2, #152]	; 0x98                         <== NOT EXECUTED
   35528:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3552c:	ebfff9fd 	bl	33d28 <rtems_rfs_block_map_grow>               <== NOT EXECUTED
                                     rtems_rfs_file_map (handle),     
                                     1, &block);                      
      if (rc > 0)                                                     
   35530:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35534:	ca00002d 	bgt	355f0 <rtems_rfs_file_io_start+0x138>         <== NOT EXECUTED
   35538:	ea00000b 	b	3556c <rtems_rfs_file_io_start+0xb4>            <== NOT EXECUTED
      /*                                                              
       * If this is a write check if the write starts within a block or the
       * amount of data is less than a block size. If it is read the block
       * rather than getting a block to fill.                         
       */                                                             
      if (!read &&                                                    
   3553c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   35540:	11a03005 	movne	r3, r5                                      <== NOT EXECUTED
   35544:	1a00000b 	bne	35578 <rtems_rfs_file_io_start+0xc0>          <== NOT EXECUTED
          (rtems_rfs_file_block_offset (handle) ||                    
   35548:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
   3554c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   35550:	1a000007 	bne	35574 <rtems_rfs_file_io_start+0xbc>          <== NOT EXECUTED
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
   35554:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35558:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   3555c:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
   35560:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
   35564:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   35568:	3a000001 	bcc	35574 <rtems_rfs_file_io_start+0xbc>          <== NOT EXECUTED
   3556c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   35570:	ea000000 	b	35578 <rtems_rfs_file_io_start+0xc0>            <== NOT EXECUTED
   35574:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                    
      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
              block, request_read ? "yes" : "no");                    
                                                                      
    rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), 
   35578:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
   3557c:	e2841004 	add	r1, r4, #4                                    <== NOT EXECUTED
   35580:	e5920098 	ldr	r0, [r2, #152]	; 0x98                         <== NOT EXECUTED
   35584:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   35588:	ebfffc54 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                          rtems_rfs_file_buffer (handle),
                                          block, request_read);       
    if (rc > 0)                                                       
   3558c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35590:	ca000016 	bgt	355f0 <rtems_rfs_file_io_start+0x138>         <== NOT EXECUTED
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
   35594:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   35598:	0a00000d 	beq	355d4 <rtems_rfs_file_io_start+0x11c>         <== NOT EXECUTED
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
   3559c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   355a0:	e5932044 	ldr	r2, [r3, #68]	; 0x44                          <== NOT EXECUTED
                                          block, request_read);       
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
   355a4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   355a8:	1a000002 	bne	355b8 <rtems_rfs_file_io_start+0x100>         <== NOT EXECUTED
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
   355ac:	e593103c 	ldr	r1, [r3, #60]	; 0x3c                          <== NOT EXECUTED
   355b0:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   355b4:	0a000003 	beq	355c8 <rtems_rfs_file_io_start+0x110>         <== NOT EXECUTED
                                          block, request_read);       
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
   355b8:	e593103c 	ldr	r1, [r3, #60]	; 0x3c                          <== NOT EXECUTED
   355bc:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
   355c0:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   355c4:	1a000002 	bne	355d4 <rtems_rfs_file_io_start+0x11c>         <== NOT EXECUTED
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
   355c8:	e5933040 	ldr	r3, [r3, #64]	; 0x40                          <== NOT EXECUTED
                                          block, request_read);       
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
   355cc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   355d0:	1a000002 	bne	355e0 <rtems_rfs_file_io_start+0x128>         <== NOT EXECUTED
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
    size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
  else                                                                
    size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));      
   355d4:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   355d8:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   355dc:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
   355e0:	e5942014 	ldr	r2, [r4, #20]                                 <== NOT EXECUTED
   355e4:	e0623003 	rsb	r3, r2, r3                                    <== NOT EXECUTED
   355e8:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
   355ec:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",       
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
   355f0:	e8bd81f8 	pop	{r3, r4, r5, r6, r7, r8, pc}                  <== NOT EXECUTED
                                                                      

00035cf0 <rtems_rfs_file_open>: int rtems_rfs_file_open (rtems_rfs_file_system* fs, rtems_rfs_ino ino, uint32_t flags, rtems_rfs_file_handle** file) {
   35cf0:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                    
    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);          
                                                                      
  *file = NULL;                                                       
   35cf4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_file_open (rtems_rfs_file_system*  fs,                      
                     rtems_rfs_ino           ino,                     
                     uint32_t                flags,                   
                     rtems_rfs_file_handle** file)                    
{                                                                     
   35cf8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                    
    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);          
                                                                      
  *file = NULL;                                                       
   35cfc:	e5835000 	str	r5, [r3]                                      <== NOT EXECUTED
  /*                                                                  
   * Allocate a new handle and initialise it. Do this before we deal with the
   * shared node data so we do not have to be concerned with reference
   * counting.                                                        
   */                                                                 
  handle = malloc (sizeof (rtems_rfs_file_handle));                   
   35d00:	e3a00020 	mov	r0, #32                                       <== NOT EXECUTED
int                                                                   
rtems_rfs_file_open (rtems_rfs_file_system*  fs,                      
                     rtems_rfs_ino           ino,                     
                     uint32_t                flags,                   
                     rtems_rfs_file_handle** file)                    
{                                                                     
   35d04:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
   35d08:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
   35d0c:	e1a09002 	mov	r9, r2                                        <== NOT EXECUTED
  /*                                                                  
   * Allocate a new handle and initialise it. Do this before we deal with the
   * shared node data so we do not have to be concerned with reference
   * counting.                                                        
   */                                                                 
  handle = malloc (sizeof (rtems_rfs_file_handle));                   
   35d10:	ebff480e 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (!handle)                                                        
   35d14:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   35d18:	0a000020 	beq	35da0 <rtems_rfs_file_open+0xb0>              <== NOT EXECUTED
    return ENOMEM;                                                    
                                                                      
  memset (handle, 0, sizeof (rtems_rfs_file_handle));                 
   35d1c:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
   35d20:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   35d24:	eb0029ac 	bl	403dc <memset>                                 <== NOT EXECUTED
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   35d28:	e584500c 	str	r5, [r4, #12]                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   35d2c:	e5c45004 	strb	r5, [r4, #4]                                 <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   35d30:	e5845008 	str	r5, [r4, #8]                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return the_chain->first;                                            
   35d34:	e5963070 	ldr	r3, [r6, #112]	; 0x70                         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
   return (Chain_Node *) &the_chain->permanent_null;                  
   35d38:	e2862074 	add	r2, r6, #116	; 0x74                           <== NOT EXECUTED
   35d3c:	ea000004 	b	35d54 <rtems_rfs_file_open+0x64>                <== NOT EXECUTED
  node = rtems_chain_first (&fs->file_shares);                        
  while (!rtems_chain_is_tail (&fs->file_shares, node))               
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
   35d40:	e5931014 	ldr	r1, [r3, #20]                                 <== NOT EXECUTED
   35d44:	e151000a 	cmp	r1, sl                                        <== NOT EXECUTED
  rtems_chain_node* node;                                             
  node = rtems_chain_first (&fs->file_shares);                        
  while (!rtems_chain_is_tail (&fs->file_shares, node))               
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
   35d48:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
    if (shared->inode.ino == ino)                                     
   35d4c:	0a000003 	beq	35d60 <rtems_rfs_file_open+0x70>              <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
   35d50:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,                 
                           rtems_rfs_ino          ino)                
{                                                                     
  rtems_chain_node* node;                                             
  node = rtems_chain_first (&fs->file_shares);                        
  while (!rtems_chain_is_tail (&fs->file_shares, node))               
   35d54:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   35d58:	1afffff8 	bne	35d40 <rtems_rfs_file_open+0x50>              <== NOT EXECUTED
   35d5c:	ea000003 	b	35d70 <rtems_rfs_file_open+0x80>                <== NOT EXECUTED
   * the reference count and return the pointer to the data.          
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, ino);                       
  if (shared)                                                         
  {                                                                   
    shared->references++;                                             
   35d60:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
   35d64:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   35d68:	e5853008 	str	r3, [r5, #8]                                  <== NOT EXECUTED
   35d6c:	ea000060 	b	35ef4 <rtems_rfs_file_open+0x204>               <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * None exists so create. Copy in the shared parts of the inode we hold in
     * memory.                                                        
     */                                                               
    shared = malloc (sizeof (rtems_rfs_file_shared));                 
   35d70:	e3a0009c 	mov	r0, #156	; 0x9c                               <== NOT EXECUTED
   35d74:	ebff47f5 	bl	7d50 <malloc>                                  <== NOT EXECUTED
    if (!shared)                                                      
   35d78:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   35d7c:	1a000009 	bne	35da8 <rtems_rfs_file_open+0xb8>              <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   35d80:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35d84:	e2841004 	add	r1, r4, #4                                    <== NOT EXECUTED
   35d88:	ebfffa0b 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   35d8c:	e584500c 	str	r5, [r4, #12]                                 <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   35d90:	e5c45004 	strb	r5, [r4, #4]                                 <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   35d94:	e5845008 	str	r5, [r4, #8]                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
   35d98:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35d9c:	ebff4644 	bl	76b4 <free>                                    <== NOT EXECUTED
   35da0:	e3a0a00c 	mov	sl, #12                                       <== NOT EXECUTED
      return ENOMEM;                                                  
   35da4:	ea000056 	b	35f04 <rtems_rfs_file_open+0x214>               <== NOT EXECUTED
    }                                                                 
                                                                      
    memset (shared, 0, sizeof (rtems_rfs_file_shared));               
   35da8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   35dac:	e3a0209c 	mov	r2, #156	; 0x9c                               <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);        
   35db0:	e285700c 	add	r7, r5, #12                                   <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return ENOMEM;                                                  
    }                                                                 
                                                                      
    memset (shared, 0, sizeof (rtems_rfs_file_shared));               
   35db4:	eb002988 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);        
   35db8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   35dbc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35dc0:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   35dc4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   35dc8:	eb0006ed 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
    if (rc > 0)                                                       
   35dcc:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   35dd0:	ca000008 	bgt	35df8 <rtems_rfs_file_open+0x108>             <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map); 
   35dd4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35dd8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   35ddc:	e2852034 	add	r2, r5, #52	; 0x34                            <== NOT EXECUTED
   35de0:	ebfff92e 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
    if (rc > 0)                                                       
   35de4:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   35de8:	da00000e 	ble	35e28 <rtems_rfs_file_open+0x138>             <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
        printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
                rc, strerror (rc));                                   
      rtems_rfs_inode_close (fs, &shared->inode);                     
   35dec:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   35df0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35df4:	eb0006bf 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      free (shared);                                                  
   35df8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   35dfc:	ebff462c 	bl	76b4 <free>                                    <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   35e00:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35e04:	e2841004 	add	r1, r4, #4                                    <== NOT EXECUTED
   35e08:	ebfff9eb 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   35e0c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   35e10:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   35e14:	e5c43004 	strb	r3, [r4, #4]                                 <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   35e18:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
   35e1c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35e20:	ebff4623 	bl	76b4 <free>                                    <== NOT EXECUTED
      return rc;                                                      
   35e24:	ea000036 	b	35f04 <rtems_rfs_file_open+0x214>               <== NOT EXECUTED
 * @return uint32_t The block count.                                  
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)      
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->block_count);             
   35e28:	e5953018 	ldr	r3, [r5, #24]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    shared->references = 1;                                           
   35e2c:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   35e30:	e5852008 	str	r2, [r5, #8]                                  <== NOT EXECUTED
   35e34:	e283200c 	add	r2, r3, #12                                   <== NOT EXECUTED
    shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
   35e38:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   35e3c:	e5d3000c 	ldrb	r0, [r3, #12]                                <== NOT EXECUTED
   35e40:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
   35e44:	e1810c00 	orr	r0, r1, r0, lsl #24                           <== NOT EXECUTED
   35e48:	e5d21002 	ldrb	r1, [r2, #2]                                 <== NOT EXECUTED
   35e4c:	e180280c 	orr	r2, r0, ip, lsl #16                           <== NOT EXECUTED
   35e50:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   35e54:	e5852084 	str	r2, [r5, #132]	; 0x84                         <== NOT EXECUTED
    shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
   35e58:	e5d3100a 	ldrb	r1, [r3, #10]                                <== NOT EXECUTED
   35e5c:	e5d3200b 	ldrb	r2, [r3, #11]                                <== NOT EXECUTED
   35e60:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   35e64:	e5852088 	str	r2, [r5, #136]	; 0x88                         <== NOT EXECUTED
 * @return rtems_rfs_time The atime.                                  
 */                                                                   
static inline rtems_rfs_time                                          
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)            
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->atime);                   
   35e68:	e2832010 	add	r2, r3, #16                                   <== NOT EXECUTED
    shared->atime = rtems_rfs_inode_get_atime (&shared->inode);       
   35e6c:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   35e70:	e5d30010 	ldrb	r0, [r3, #16]                                <== NOT EXECUTED
   35e74:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
   35e78:	e1810c00 	orr	r0, r1, r0, lsl #24                           <== NOT EXECUTED
   35e7c:	e5d21002 	ldrb	r1, [r2, #2]                                 <== NOT EXECUTED
   35e80:	e180280c 	orr	r2, r0, ip, lsl #16                           <== NOT EXECUTED
   35e84:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   35e88:	e585208c 	str	r2, [r5, #140]	; 0x8c                         <== NOT EXECUTED
 * @return rtems_rfs_time The mtime.                                  
 */                                                                   
static inline rtems_rfs_time                                          
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)            
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->mtime);                   
   35e8c:	e2832014 	add	r2, r3, #20                                   <== NOT EXECUTED
    shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);       
   35e90:	e5d21003 	ldrb	r1, [r2, #3]                                 <== NOT EXECUTED
   35e94:	e5d30014 	ldrb	r0, [r3, #20]                                <== NOT EXECUTED
   35e98:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
   35e9c:	e1810c00 	orr	r0, r1, r0, lsl #24                           <== NOT EXECUTED
   35ea0:	e5d21002 	ldrb	r1, [r2, #2]                                 <== NOT EXECUTED
   35ea4:	e180280c 	orr	r2, r0, ip, lsl #16                           <== NOT EXECUTED
   35ea8:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   35eac:	e5852090 	str	r2, [r5, #144]	; 0x90                         <== NOT EXECUTED
 * @return rtems_rfs_time The ctime.                                  
 */                                                                   
static inline rtems_rfs_time                                          
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)            
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->ctime);                   
   35eb0:	e2832018 	add	r2, r3, #24                                   <== NOT EXECUTED
    shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);       
   35eb4:	e5d30018 	ldrb	r0, [r3, #24]                                <== NOT EXECUTED
   35eb8:	e5d23003 	ldrb	r3, [r2, #3]                                 <== NOT EXECUTED
   35ebc:	e5d21001 	ldrb	r1, [r2, #1]                                 <== NOT EXECUTED
   35ec0:	e1833c00 	orr	r3, r3, r0, lsl #24                           <== NOT EXECUTED
   35ec4:	e5d22002 	ldrb	r2, [r2, #2]                                 <== NOT EXECUTED
   35ec8:	e1833801 	orr	r3, r3, r1, lsl #16                           <== NOT EXECUTED
   35ecc:	e1833402 	orr	r3, r3, r2, lsl #8                            <== 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 );                               
   35ed0:	e2860070 	add	r0, r6, #112	; 0x70                           <== NOT EXECUTED
   35ed4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   35ed8:	e5853094 	str	r3, [r5, #148]	; 0x94                         <== NOT EXECUTED
    shared->fs = fs;                                                  
   35edc:	e5856098 	str	r6, [r5, #152]	; 0x98                         <== NOT EXECUTED
   35ee0:	ebff594b 	bl	c414 <_Chain_Append>                           <== NOT EXECUTED
                                                                      
    rtems_chain_append (&fs->file_shares, &shared->link);             
                                                                      
    rtems_rfs_inode_unload (fs, &shared->inode, false);               
   35ee4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35ee8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   35eec:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   35ef0:	eb000656 	bl	37850 <rtems_rfs_inode_unload>                 <== NOT EXECUTED
  }                                                                   
                                                                      
  handle->flags  = flags;                                             
  handle->shared = shared;                                            
                                                                      
  *file = handle;                                                     
   35ef4:	e5884000 	str	r4, [r8]                                      <== NOT EXECUTED
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
      printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
  }                                                                   
                                                                      
  handle->flags  = flags;                                             
   35ef8:	e5849000 	str	r9, [r4]                                      <== NOT EXECUTED
  handle->shared = shared;                                            
   35efc:	e584501c 	str	r5, [r4, #28]                                 <== NOT EXECUTED
                                                                      
  *file = handle;                                                     
   35f00:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   35f04:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   35f08:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

000358dc <rtems_rfs_file_seek>: int rtems_rfs_file_seek (rtems_rfs_file_handle* handle, rtems_rfs_pos pos, rtems_rfs_pos* new_pos) {
   358dc:	e92d41f1 	push	{r0, r4, r5, r6, r7, r8, lr}                 <== NOT EXECUTED
   358e0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   *     file, this function does not itself extend the size of the file."
   *                                                                  
   * This means the file needs to set the file size to the pos only when a
   * write occurs.                                                    
   */                                                                 
  if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
   358e4:	e590001c 	ldr	r0, [r0, #28]                                 <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,                   
                     rtems_rfs_pos          pos,                      
                     rtems_rfs_pos*         new_pos)                  
{                                                                     
   358e8:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   358ec:	e2801084 	add	r1, r0, #132	; 0x84                           <== NOT EXECUTED
   358f0:	e5900098 	ldr	r0, [r0, #152]	; 0x98                         <== NOT EXECUTED
   358f4:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   358f8:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
   358fc:	ebfff73e 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
   *     file, this function does not itself extend the size of the file."
   *                                                                  
   * This means the file needs to set the file size to the pos only when a
   * write occurs.                                                    
   */                                                                 
  if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
   35900:	e1510006 	cmp	r1, r6                                        <== NOT EXECUTED
   35904:	8a000002 	bhi	35914 <rtems_rfs_file_seek+0x38>              <== NOT EXECUTED
   35908:	1a00001c 	bne	35980 <rtems_rfs_file_seek+0xa4>              <== NOT EXECUTED
   3590c:	e1500005 	cmp	r0, r5                                        <== NOT EXECUTED
   35910:	9a00001a 	bls	35980 <rtems_rfs_file_seek+0xa4>              <== NOT EXECUTED
                                            handle->shared))          
  {                                                                   
    rtems_rfs_file_set_bpos (handle, pos);                            
   35914:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35918:	e2847010 	add	r7, r4, #16                                   <== NOT EXECUTED
   3591c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   35920:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   35924:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   35928:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   3592c:	ebfff703 	bl	33540 <rtems_rfs_block_get_bpos>               <== NOT EXECUTED
    /*                                                                
     * If the file has a block check if it maps to the current position and it
     * does not release it. That will force us to get the block at the new
     * position when the I/O starts.                                  
     */                                                               
    if (rtems_rfs_buffer_handle_has_block (&handle->buffer))          
   35930:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   35934:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   35938:	0a000014 	beq	35990 <rtems_rfs_file_seek+0xb4>              <== NOT EXECUTED
    {                                                                 
      rtems_rfs_buffer_block block;                                   
      int                    rc;                                      
                                                                      
      rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),      
   3593c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35940:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   35944:	e2831034 	add	r1, r3, #52	; 0x34                            <== NOT EXECUTED
   35948:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   3594c:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   35950:	ebfff757 	bl	336b4 <rtems_rfs_block_map_find>               <== NOT EXECUTED
                                     rtems_rfs_file_map (handle),     
                                     rtems_rfs_file_bpos (handle),    
                                     &block);                         
      if (rc > 0)                                                     
   35954:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35958:	ca00000e 	bgt	35998 <rtems_rfs_file_seek+0xbc>              <== NOT EXECUTED
        return rc;                                                    
      if (rtems_rfs_buffer_bnum (&handle->buffer) != block)           
   3595c:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
   35960:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   35964:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   35968:	0a000008 	beq	35990 <rtems_rfs_file_seek+0xb4>              <== NOT EXECUTED
      {                                                               
        rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
   3596c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35970:	e2841004 	add	r1, r4, #4                                    <== NOT EXECUTED
   35974:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   35978:	ebfffb0f 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
   3597c:	ea000001 	b	35988 <rtems_rfs_file_seek+0xac>                <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The seek is outside the current file so release any buffer. A write will
     * extend the file.                                               
     */                                                               
    int rc = rtems_rfs_file_io_release (handle);                      
   35980:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35984:	ebffff1a 	bl	355f4 <rtems_rfs_file_io_release>              <== NOT EXECUTED
    if (rc > 0)                                                       
   35988:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3598c:	ca000001 	bgt	35998 <rtems_rfs_file_seek+0xbc>              <== NOT EXECUTED
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
   35990:	e8880060 	stm	r8, {r5, r6}                                  <== NOT EXECUTED
   35994:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   35998:	e8bd81f8 	pop	{r3, r4, r5, r6, r7, r8, pc}                  <== NOT EXECUTED
                                                                      

00035614 <rtems_rfs_file_set_size>: } int rtems_rfs_file_set_size (rtems_rfs_file_handle* handle, rtems_rfs_pos new_size) {
   35614:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
   35618:	e590501c 	ldr	r5, [r0, #28]                                 <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,               
                         rtems_rfs_pos          new_size)             
{                                                                     
   3561c:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   35620:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
   35624:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   35628:	e2851084 	add	r1, r5, #132	; 0x84                           <== NOT EXECUTED
   3562c:	e5950098 	ldr	r0, [r5, #152]	; 0x98                         <== NOT EXECUTED
   35630:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   35634:	ebfff7f0 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
  /*                                                                  
   * If the file is same size do nothing else grow or shrink it ?     
   *                                                                  
   * If the file does not change size do not update the times.        
   */                                                                 
  if (size != new_size)                                               
   35638:	e1500006 	cmp	r0, r6                                        <== NOT EXECUTED
   3563c:	1a000001 	bne	35648 <rtems_rfs_file_set_size+0x34>          <== NOT EXECUTED
   35640:	e1510007 	cmp	r1, r7                                        <== NOT EXECUTED
   35644:	0a0000a1 	beq	358d0 <rtems_rfs_file_set_size+0x2bc>         <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
   35648:	e1962007 	orrs	r2, r6, r7                                   <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,               
                         rtems_rfs_pos          new_size)             
{                                                                     
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
   3564c:	e2859034 	add	r9, r5, #52	; 0x34                            <== NOT EXECUTED
  if (size != new_size)                                               
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
   35650:	1a000006 	bne	35670 <rtems_rfs_file_set_size+0x5c>          <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
   35654:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35658:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   3565c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   35660:	ebfff968 	bl	33c08 <rtems_rfs_block_map_free_all>           <== NOT EXECUTED
      if (rc > 0)                                                     
   35664:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35668:	ca000099 	bgt	358d4 <rtems_rfs_file_set_size+0x2c0>         <== NOT EXECUTED
   3566c:	ea00008a 	b	3589c <rtems_rfs_file_set_size+0x288>           <== NOT EXECUTED
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
   35670:	e1570001 	cmp	r7, r1                                        <== NOT EXECUTED
   35674:	8a000002 	bhi	35684 <rtems_rfs_file_set_size+0x70>          <== NOT EXECUTED
   35678:	1a000054 	bne	357d0 <rtems_rfs_file_set_size+0x1bc>         <== NOT EXECUTED
   3567c:	e1560000 	cmp	r6, r0                                        <== NOT EXECUTED
   35680:	9a000052 	bls	357d0 <rtems_rfs_file_set_size+0x1bc>         <== NOT EXECUTED
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
   35684:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35688:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
          }                                                           
                                                                      
          /*                                                          
           * Only read the block if the length is not the block size. 
           */                                                         
          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
   3568c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
   35690:	e1a0a006 	mov	sl, r6                                        <== NOT EXECUTED
   35694:	e1a0b007 	mov	fp, r7                                        <== NOT EXECUTED
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
   35698:	e5936008 	ldr	r6, [r3, #8]                                  <== NOT EXECUTED
          }                                                           
                                                                      
          /*                                                          
           * Only read the block if the length is not the block size. 
           */                                                         
          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
   3569c:	e2843004 	add	r3, r4, #4                                    <== NOT EXECUTED
   356a0:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
   356a4:	e05aa000 	subs	sl, sl, r0                                   <== NOT EXECUTED
   356a8:	e0cbb001 	sbc	fp, fp, r1                                    <== NOT EXECUTED
          }                                                           
                                                                      
          /*                                                          
           * Only read the block if the length is not the block size. 
           */                                                         
          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
   356ac:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
          /*                                                          
           * Get the block position for the current end of the file as seen by
           * the map. If not found and the EOF grow the map then fill the block
           * with 0.                                                  
           */                                                         
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
   356b0:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
             * Have we reached the EOF ?                              
             */                                                       
            if (rc != ENXIO)                                          
              return rc;                                              
                                                                      
            rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
   356b4:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
                                                                      
        count = new_size - size;                                      
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
        read_block = false;                                           
                                                                      
        while (count)                                                 
   356b8:	ea000041 	b	357c4 <rtems_rfs_file_set_size+0x1b0>           <== NOT EXECUTED
          /*                                                          
           * Get the block position for the current end of the file as seen by
           * the map. If not found and the EOF grow the map then fill the block
           * with 0.                                                  
           */                                                         
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
   356bc:	e595303c 	ldr	r3, [r5, #60]	; 0x3c                          <== NOT EXECUTED
   356c0:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   356c4:	e5952040 	ldr	r2, [r5, #64]	; 0x40                          <== NOT EXECUTED
   356c8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   356cc:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
   356d0:	158d3008 	strne	r3, [sp, #8]                                <== NOT EXECUTED
          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),  
   356d4:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
          /*                                                          
           * Get the block position for the current end of the file as seen by
           * the map. If not found and the EOF grow the map then fill the block
           * with 0.                                                  
           */                                                         
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
   356d8:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),  
   356dc:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   356e0:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   356e4:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
   356e8:	e28d3014 	add	r3, sp, #20                                   <== NOT EXECUTED
          /*                                                          
           * Get the block position for the current end of the file as seen by
           * the map. If not found and the EOF grow the map then fill the block
           * with 0.                                                  
           */                                                         
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
   356ec:	e58d7010 	str	r7, [sp, #16]                                 <== NOT EXECUTED
          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),  
   356f0:	ebfff7ef 	bl	336b4 <rtems_rfs_block_map_find>               <== NOT EXECUTED
                                         map, &bpos, &block);         
          if (rc > 0)                                                 
   356f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   356f8:	da000009 	ble	35724 <rtems_rfs_file_set_size+0x110>         <== NOT EXECUTED
          {                                                           
            /*                                                        
             * Have we reached the EOF ?                              
             */                                                       
            if (rc != ENXIO)                                          
   356fc:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
   35700:	1a000073 	bne	358d4 <rtems_rfs_file_set_size+0x2c0>         <== NOT EXECUTED
              return rc;                                              
                                                                      
            rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
   35704:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35708:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   3570c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   35710:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   35714:	e28d3014 	add	r3, sp, #20                                   <== NOT EXECUTED
   35718:	ebfff982 	bl	33d28 <rtems_rfs_block_map_grow>               <== NOT EXECUTED
                                           map, 1, &block);           
            if (rc > 0)                                               
   3571c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35720:	ca00006b 	bgt	358d4 <rtems_rfs_file_set_size+0x2c0>         <== NOT EXECUTED
              return rc;                                              
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
   35724:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   35728:	e157000b 	cmp	r7, fp                                        <== NOT EXECUTED
   3572c:	e0632006 	rsb	r2, r3, r6                                    <== NOT EXECUTED
   35730:	1a000007 	bne	35754 <rtems_rfs_file_set_size+0x140>         <== NOT EXECUTED
   35734:	e152000a 	cmp	r2, sl                                        <== NOT EXECUTED
   35738:	9a000005 	bls	35754 <rtems_rfs_file_set_size+0x140>         <== NOT EXECUTED
          {                                                           
            length = count + bpos.boff;                               
   3573c:	e083600a 	add	r6, r3, sl                                    <== NOT EXECUTED
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
  map->dirty = true;                                                  
   35740:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
   35744:	e5856040 	str	r6, [r5, #64]	; 0x40                          <== NOT EXECUTED
  map->dirty = true;                                                  
   35748:	e5c58034 	strb	r8, [r5, #52]	; 0x34                         <== NOT EXECUTED
   3574c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
   35750:	ea000001 	b	3575c <rtems_rfs_file_set_size+0x148>           <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
   35754:	e5857040 	str	r7, [r5, #64]	; 0x40                          <== NOT EXECUTED
  map->dirty = true;                                                  
   35758:	e5c58034 	strb	r8, [r5, #52]	; 0x34                         <== NOT EXECUTED
          }                                                           
                                                                      
          /*                                                          
           * Only read the block if the length is not the block size. 
           */                                                         
          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
   3575c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   35760:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   35764:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   35768:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   3576c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   35770:	ebfffbda 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                                rtems_rfs_file_buffer (handle),
                                                block, read_block);   
          if (rc > 0)                                                 
   35774:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35778:	ca000055 	bgt	358d4 <rtems_rfs_file_set_size+0x2c0>         <== NOT EXECUTED
            return rc;                                                
                                                                      
          dst = rtems_rfs_buffer_data (&handle->buffer);              
          memset (dst + bpos.boff, 0, length - bpos.boff);            
   3577c:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   35780:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   35784:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   35788:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   3578c:	e0632006 	rsb	r2, r3, r6                                    <== NOT EXECUTED
   35790:	e0800003 	add	r0, r0, r3                                    <== NOT EXECUTED
   35794:	eb002b10 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
          rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
   35798:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
            return rc;                                                
                                                                      
          dst = rtems_rfs_buffer_data (&handle->buffer);              
          memset (dst + bpos.boff, 0, length - bpos.boff);            
                                                                      
          rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
   3579c:	e5c48004 	strb	r8, [r4, #4]                                 <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
   357a0:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   357a4:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   357a8:	ebfffb83 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
                                                rtems_rfs_file_buffer (handle));
          if (rc > 0)                                                 
   357ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   357b0:	ca000047 	bgt	358d4 <rtems_rfs_file_set_size+0x2c0>         <== NOT EXECUTED
            return rc;                                                
                                                                      
          count -= length - bpos.boff;                                
   357b4:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   357b8:	e0633006 	rsb	r3, r3, r6                                    <== NOT EXECUTED
   357bc:	e05aa003 	subs	sl, sl, r3                                   <== NOT EXECUTED
   357c0:	e2cbb000 	sbc	fp, fp, #0                                    <== NOT EXECUTED
                                                                      
        count = new_size - size;                                      
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
        read_block = false;                                           
                                                                      
        while (count)                                                 
   357c4:	e19a300b 	orrs	r3, sl, fp                                   <== NOT EXECUTED
   357c8:	1affffbb 	bne	356bc <rtems_rfs_file_set_size+0xa8>          <== NOT EXECUTED
   357cc:	ea000032 	b	3589c <rtems_rfs_file_set_size+0x288>           <== NOT EXECUTED
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
   357d0:	e594a01c 	ldr	sl, [r4, #28]                                 <== NOT EXECUTED
   357d4:	e59a8098 	ldr	r8, [sl, #152]	; 0x98                         <== NOT EXECUTED
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
   357d8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
   357dc:	e5989008 	ldr	r9, [r8, #8]                                  <== NOT EXECUTED
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
   357e0:	e0900006 	adds	r0, r0, r6                                   <== NOT EXECUTED
   357e4:	e3e01000 	mvn	r1, #0                                        <== NOT EXECUTED
   357e8:	e0a11007 	adc	r1, r1, r7                                    <== NOT EXECUTED
   357ec:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   357f0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   357f4:	eb008199 	bl	55e60 <__udivdi3>                              <== NOT EXECUTED
   357f8:	e595303c 	ldr	r3, [r5, #60]	; 0x3c                          <== NOT EXECUTED
   357fc:	e1e02000 	mvn	r2, r0                                        <== NOT EXECUTED
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
                                                                      
        offset =                                                      
          new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
                                                                      
        if (blocks)                                                   
   35800:	e0922003 	adds	r2, r2, r3                                   <== NOT EXECUTED
   35804:	0a000004 	beq	3581c <rtems_rfs_file_set_size+0x208>         <== NOT EXECUTED
        {                                                             
          int rc;                                                     
          rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
   35808:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   3580c:	e28a1034 	add	r1, sl, #52	; 0x34                            <== NOT EXECUTED
   35810:	ebfff84c 	bl	33948 <rtems_rfs_block_map_shrink>             <== NOT EXECUTED
                                           rtems_rfs_file_map (handle),
                                           blocks);                   
          if (rc > 0)                                                 
   35814:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   35818:	ca00002d 	bgt	358d4 <rtems_rfs_file_set_size+0x2c0>         <== NOT EXECUTED
        blocks =                                                      
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
                                                                      
        offset =                                                      
   3581c:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   35820:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   35824:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   35828:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   3582c:	eb00829c 	bl	562a4 <__umoddi3>                              <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
   35830:	e5850040 	str	r0, [r5, #64]	; 0x40                          <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
        rtems_rfs_block_map_set_size_offset (map, offset);            
                                                                      
        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
   35834:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
  map->dirty = true;                                                  
   35838:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   3583c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   35840:	e5c52034 	strb	r2, [r5, #52]	; 0x34                         <== NOT EXECUTED
   35844:	0a000002 	beq	35854 <rtems_rfs_file_set_size+0x240>         <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,               
                         rtems_rfs_pos          new_size)             
{                                                                     
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
   35848:	e595203c 	ldr	r2, [r5, #60]	; 0x3c                          <== NOT EXECUTED
   3584c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   35850:	0a000008 	beq	35878 <rtems_rfs_file_set_size+0x264>         <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
        rtems_rfs_block_map_set_size_offset (map, offset);            
                                                                      
        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
   35854:	e595203c 	ldr	r2, [r5, #60]	; 0x3c                          <== NOT EXECUTED
   35858:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   3585c:	2a000005 	bcs	35878 <rtems_rfs_file_set_size+0x264>         <== NOT EXECUTED
   35860:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   35864:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   35868:	1a00000b 	bne	3589c <rtems_rfs_file_set_size+0x288>         <== NOT EXECUTED
   3586c:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
   35870:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
   35874:	9a000008 	bls	3589c <rtems_rfs_file_set_size+0x288>         <== NOT EXECUTED
                                          rtems_rfs_block_map_size (map)))
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
   35878:	e595303c 	ldr	r3, [r5, #60]	; 0x3c                          <== NOT EXECUTED
   3587c:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
   35880:	e5952040 	ldr	r2, [r5, #64]	; 0x40                          <== NOT EXECUTED
   35884:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   35888:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   3588c:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
   35890:	e5841018 	str	r1, [r4, #24]                                 <== NOT EXECUTED
   35894:	e5842014 	str	r2, [r4, #20]                                 <== NOT EXECUTED
   35898:	15843010 	strne	r3, [r4, #16]                               <== NOT EXECUTED
                                         rtems_rfs_file_bpos (handle));
      }                                                               
    }                                                                 
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
   3589c:	e594601c 	ldr	r6, [r4, #28]                                 <== NOT EXECUTED
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
   358a0:	e5952040 	ldr	r2, [r5, #64]	; 0x40                          <== NOT EXECUTED
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
                                         rtems_rfs_file_bpos (handle));
      }                                                               
    }                                                                 
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
   358a4:	e595303c 	ldr	r3, [r5, #60]	; 0x3c                          <== NOT EXECUTED
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
   358a8:	e5862088 	str	r2, [r6, #136]	; 0x88                         <== NOT EXECUTED
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
                                         rtems_rfs_file_bpos (handle));
      }                                                               
    }                                                                 
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
   358ac:	e5863084 	str	r3, [r6, #132]	; 0x84                         <== NOT EXECUTED
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
   358b0:	e5944000 	ldr	r4, [r4]                                      <== NOT EXECUTED
   358b4:	e2144002 	ands	r4, r4, #2                                   <== NOT EXECUTED
   358b8:	1a000004 	bne	358d0 <rtems_rfs_file_set_size+0x2bc>         <== NOT EXECUTED
      handle->shared->mtime = time (NULL);                            
   358bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   358c0:	eb004d00 	bl	48cc8 <time>                                   <== NOT EXECUTED
   358c4:	e5860090 	str	r0, [r6, #144]	; 0x90                         <== NOT EXECUTED
   358c8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   358cc:	ea000000 	b	358d4 <rtems_rfs_file_set_size+0x2c0>           <== NOT EXECUTED
   358d0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   358d4:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
   358d8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

000364f8 <rtems_rfs_format>: return rc; } int rtems_rfs_format (const char* name, const rtems_rfs_format_config* config) {
   364f8:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
   364fc:	e5d13015 	ldrb	r3, [r1, #21]                                <== NOT EXECUTED
  return rc;                                                          
}                                                                     
                                                                      
int                                                                   
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{                                                                     
   36500:	e24dd0ec 	sub	sp, sp, #236	; 0xec                           <== NOT EXECUTED
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
   36504:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  return rc;                                                          
}                                                                     
                                                                      
int                                                                   
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{                                                                     
   36508:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
   3650c:	e58d000c 	str	r0, [sp, #12]                                 <== NOT EXECUTED
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
    printf ("rtems-rfs: format: %s\n", name);                         
   36510:	159f0b5c 	ldrne	r0, [pc, #2908]	; 37074 <rtems_rfs_format+0xb7c><== NOT EXECUTED
   36514:	159d100c 	ldrne	r1, [sp, #12]                               <== NOT EXECUTED
   36518:	1b002bd6 	blne	41478 <printf>                               <== NOT EXECUTED
                                                                      
  memset (&fs, 0, sizeof (rtems_rfs_file_system));                    
   3651c:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
   36520:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   36524:	e3a02080 	mov	r2, #128	; 0x80                               <== NOT EXECUTED
   36528:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3652c:	eb0027aa 	bl	403dc <memset>                                 <== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);                 
   36530:	e2843070 	add	r3, r4, #112	; 0x70                           <== NOT EXECUTED
   36534:	e58d3090 	str	r3, [sp, #144]	; 0x90                         <== NOT EXECUTED
  rtems_chain_initialize_empty (&fs.buffers);                         
  rtems_chain_initialize_empty (&fs.release);                         
  rtems_chain_initialize_empty (&fs.release_modified);                
  rtems_chain_initialize_empty (&fs.file_shares);                     
                                                                      
  fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;                
   36538:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   3653c:	e2845050 	add	r5, r4, #80	; 0x50                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36540:	e284e064 	add	lr, r4, #100	; 0x64                           <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36544:	e284c060 	add	ip, r4, #96	; 0x60                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36548:	e2842074 	add	r2, r4, #116	; 0x74                           <== NOT EXECUTED
   3654c:	e58d3054 	str	r3, [sp, #84]	; 0x54                          <== NOT EXECUTED
   36550:	e284a044 	add	sl, r4, #68	; 0x44                            <== NOT EXECUTED
                                                                      
  fs.release_count = 0;                                               
  fs.release_modified_count = 0;                                      
                                                                      
  fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;                             
   36554:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36558:	e2848040 	add	r8, r4, #64	; 0x40                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   3655c:	e2846054 	add	r6, r4, #84	; 0x54                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
   36560:	e59d000c 	ldr	r0, [sp, #12]                                 <== NOT EXECUTED
   36564:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36568:	e58d5070 	str	r5, [sp, #112]	; 0x70                         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   3656c:	e58da058 	str	sl, [sp, #88]	; 0x58                          <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36570:	e58d8060 	str	r8, [sp, #96]	; 0x60                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36574:	e58d6068 	str	r6, [sp, #104]	; 0x68                         <== NOT EXECUTED
   36578:	e58de078 	str	lr, [sp, #120]	; 0x78                         <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   3657c:	e58dc080 	str	ip, [sp, #128]	; 0x80                         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36580:	e58d2088 	str	r2, [sp, #136]	; 0x88                         <== NOT EXECUTED
  fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;                
                                                                      
  fs.release_count = 0;                                               
  fs.release_modified_count = 0;                                      
                                                                      
  fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;                             
   36584:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
   36588:	ebfff7f5 	bl	34564 <rtems_rfs_buffer_open>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   3658c:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   36590:	da000004 	ble	365a8 <rtems_rfs_format+0xb0>                 <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: buffer open failed: %d: %s\n",        
   36594:	eb0033ca 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36598:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   3659c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   365a0:	e59f0ad0 	ldr	r0, [pc, #2768]	; 37078 <rtems_rfs_format+0xb80><== NOT EXECUTED
   365a4:	ea0002ac 	b	3705c <rtems_rfs_format+0xb64>                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
   365a8:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   365ac:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
   365b0:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",       
   365b4:	059f0ac0 	ldreq	r0, [pc, #2752]	; 3707c <rtems_rfs_format+0xb84><== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
   365b8:	0a00014e 	beq	36af8 <rtems_rfs_format+0x600>                <== NOT EXECUTED
                                                                      
static bool                                                           
rtems_rfs_check_config (rtems_rfs_file_system*         fs,            
                        const rtems_rfs_format_config* config)        
{                                                                     
  fs->block_size = config->block_size;                                
   365bc:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
  if (!fs->block_size)                                                
   365c0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
static bool                                                           
rtems_rfs_check_config (rtems_rfs_file_system*         fs,            
                        const rtems_rfs_format_config* config)        
{                                                                     
  fs->block_size = config->block_size;                                
   365c4:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
  if (!fs->block_size)                                                
   365c8:	1a00001c 	bne	36640 <rtems_rfs_format+0x148>                <== NOT EXECUTED
  {                                                                   
    uint64_t total_size = rtems_rfs_fs_media_size (fs);               
   365cc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   365d0:	ebfffe54 	bl	35f28 <rtems_rfs_fs_media_size>                <== NOT EXECUTED
                                                                      
    if (total_size >= GIGS (1))                                       
   365d4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   365d8:	1a000001 	bne	365e4 <rtems_rfs_format+0xec>                 <== NOT EXECUTED
   365dc:	e3500601 	cmp	r0, #1048576	; 0x100000                       <== NOT EXECUTED
   365e0:	3a00000e 	bcc	36620 <rtems_rfs_format+0x128>                <== NOT EXECUTED
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
   365e4:	e3a03601 	mov	r3, #1048576	; 0x100000                       <== NOT EXECUTED
   365e8:	e0933000 	adds	r3, r3, r0                                   <== NOT EXECUTED
   365ec:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   365f0:	e0a44001 	adc	r4, r4, r1                                    <== NOT EXECUTED
   365f4:	e1a01a23 	lsr	r1, r3, #20                                   <== NOT EXECUTED
   365f8:	e1811604 	orr	r1, r1, r4, lsl #12                           <== NOT EXECUTED
   365fc:	e3a0301f 	mov	r3, #31                                       <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
        if ((gigs & (1 << b)) != 0)                                   
   36600:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   36604:	e0110312 	ands	r0, r1, r2, lsl r3                           <== NOT EXECUTED
   36608:	1a000001 	bne	36614 <rtems_rfs_format+0x11c>                <== NOT EXECUTED
                                                                      
    if (total_size >= GIGS (1))                                       
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
   3660c:	e2533001 	subs	r3, r3, #1                                   <== NOT EXECUTED
   36610:	1afffffb 	bne	36604 <rtems_rfs_format+0x10c>                <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
          break;                                                      
      fs->block_size = 1 << b;                                        
   36614:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   36618:	e1a03312 	lsl	r3, r2, r3                                    <== NOT EXECUTED
   3661c:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
   36620:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   36624:	e3530c02 	cmp	r3, #512	; 0x200                              <== NOT EXECUTED
      fs->block_size = 512;                                           
   36628:	33a03c02 	movcc	r3, #512	; 0x200                            <== NOT EXECUTED
   3662c:	358d3020 	strcc	r3, [sp, #32]                               <== NOT EXECUTED
                                                                      
    if (fs->block_size > (4 * 1024))                                  
   36630:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   36634:	e3530a01 	cmp	r3, #4096	; 0x1000                            <== NOT EXECUTED
      fs->block_size = (4 * 1024);                                    
   36638:	83a03a01 	movhi	r3, #4096	; 0x1000                          <== NOT EXECUTED
   3663c:	858d3020 	strhi	r3, [sp, #32]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)     
   36640:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   36644:	e59d4020 	ldr	r4, [sp, #32]                                 <== NOT EXECUTED
   36648:	e5935024 	ldr	r5, [r3, #36]	; 0x24                          <== NOT EXECUTED
   3664c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   36650:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   36654:	eb007a7b 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   36658:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  {                                                                   
    printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
   3665c:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
   36660:	11a02005 	movne	r2, r5                                      <== NOT EXECUTED
   36664:	159f0a14 	ldrne	r0, [pc, #2580]	; 37080 <rtems_rfs_format+0xb88><== NOT EXECUTED
   36668:	1a00027b 	bne	3705c <rtems_rfs_format+0xb64>                <== NOT EXECUTED
            fs->block_size, rtems_rfs_fs_media_block_size (fs));      
    return false;                                                     
  }                                                                   
                                                                      
  fs->group_blocks = config->group_blocks;                            
   3666c:	e5973004 	ldr	r3, [r7, #4]                                  <== NOT EXECUTED
  if (!fs->group_blocks)                                              
   36670:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The number of blocks per group is defined by the number of bits in a
     * block.                                                         
     */                                                               
    fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);  
   36674:	01a04184 	lsleq	r4, r4, #3                                  <== NOT EXECUTED
    printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
            fs->block_size, rtems_rfs_fs_media_block_size (fs));      
    return false;                                                     
  }                                                                   
                                                                      
  fs->group_blocks = config->group_blocks;                            
   36678:	e58d303c 	str	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The number of blocks per group is defined by the number of bits in a
     * block.                                                         
     */                                                               
    fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);  
   3667c:	058d403c 	streq	r4, [sp, #60]	; 0x3c                        <== NOT EXECUTED
  }                                                                   
                                                                      
  if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
   36680:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
   36684:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   36688:	e1530182 	cmp	r3, r2, lsl #3                                <== NOT EXECUTED
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
   3668c:	859f09f0 	ldrhi	r0, [pc, #2544]	; 37084 <rtems_rfs_format+0xb8c><== NOT EXECUTED
     * block.                                                         
     */                                                               
    fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);  
  }                                                                   
                                                                      
  if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
   36690:	8a00010b 	bhi	36ac4 <rtems_rfs_format+0x5cc>                <== NOT EXECUTED
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
    return false;                                                     
  }                                                                   
                                                                      
  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;         
   36694:	e28d0018 	add	r0, sp, #24                                   <== NOT EXECUTED
   36698:	ebfffe22 	bl	35f28 <rtems_rfs_fs_media_size>                <== NOT EXECUTED
   3669c:	e59d4020 	ldr	r4, [sp, #32]                                 <== NOT EXECUTED
   366a0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   366a4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   366a8:	eb007dec 	bl	55e60 <__udivdi3>                              <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   366ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
    return false;                                                     
  }                                                                   
                                                                      
  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;         
   366b0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   366b4:	e58d001c 	str	r0, [sp, #28]                                 <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   366b8:	03a04001 	moveq	r4, #1                                      <== NOT EXECUTED
   366bc:	0a000003 	beq	366d0 <rtems_rfs_format+0x1d8>                <== NOT EXECUTED
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
   366c0:	e1a01184 	lsl	r1, r4, #3                                    <== NOT EXECUTED
   366c4:	e2450001 	sub	r0, r5, #1                                    <== NOT EXECUTED
   366c8:	eb0079ca 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   366cc:	e2804001 	add	r4, r0, #1                                    <== NOT EXECUTED
   * per block.                                                       
   */                                                                 
  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs), 
                                            rtems_rfs_bits_per_block (fs));
                                                                      
  fs->group_inodes = config->group_inodes;                            
   366d0:	e5973008 	ldr	r3, [r7, #8]                                  <== NOT EXECUTED
  if (!fs->group_inodes)                                              
   366d4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  /*                                                                  
   * The bits per block sets the upper limit for the number of blocks in a
   * group. The disk will be divided into groups which are the number of bits
   * per block.                                                       
   */                                                                 
  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs), 
   366d8:	e58d4038 	str	r4, [sp, #56]	; 0x38                          <== NOT EXECUTED
                                            rtems_rfs_bits_per_block (fs));
                                                                      
  fs->group_inodes = config->group_inodes;                            
   366dc:	e58d3040 	str	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
  if (!fs->group_inodes)                                              
   366e0:	1a000012 	bne	36730 <rtems_rfs_format+0x238>                <== NOT EXECUTED
    int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;         
                                                                      
    /*                                                                
     * The number of inodes per group is set as a percentage.         
     */                                                               
    if (config->inode_overhead)                                       
   366e4:	e597300c 	ldr	r3, [r7, #12]                                 <== NOT EXECUTED
   366e8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   366ec:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
static int                                                            
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,             
                               int                    percentage)     
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
   366f0:	e2450001 	sub	r0, r5, #1                                    <== NOT EXECUTED
   366f4:	e0000093 	mul	r0, r3, r0                                    <== NOT EXECUTED
   366f8:	e3a01064 	mov	r1, #100	; 0x64                               <== NOT EXECUTED
   366fc:	eb0079bd 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   36700:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   36704:	03a04001 	moveq	r4, #1                                      <== NOT EXECUTED
   36708:	0a000003 	beq	3671c <rtems_rfs_format+0x224>                <== NOT EXECUTED
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
   3670c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36710:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
   36714:	eb0079b7 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   36718:	e2804001 	add	r4, r0, #1                                    <== NOT EXECUTED
     * The number of inodes per group is set as a percentage.         
     */                                                               
    if (config->inode_overhead)                                       
      inode_overhead = config->inode_overhead;                        
                                                                      
    fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
   3671c:	e59d0020 	ldr	r0, [sp, #32]                                 <== NOT EXECUTED
   36720:	e3a01038 	mov	r1, #56	; 0x38                                <== NOT EXECUTED
   36724:	eb0079b3 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   36728:	e0000094 	mul	r0, r4, r0                                    <== NOT EXECUTED
   3672c:	e58d0040 	str	r0, [sp, #64]	; 0x40                          <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Round up to fill a block because the minimum allocation unit is a block.
   */                                                                 
  fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
   36730:	e59d0020 	ldr	r0, [sp, #32]                                 <== NOT EXECUTED
   36734:	e3a01038 	mov	r1, #56	; 0x38                                <== NOT EXECUTED
   36738:	eb0079ae 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   3673c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  fs->group_inodes =                                                  
    rtems_rfs_rup_quotient (fs->group_inodes,                         
   36740:	e59d0040 	ldr	r0, [sp, #64]	; 0x40                          <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   36744:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Round up to fill a block because the minimum allocation unit is a block.
   */                                                                 
  fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
   36748:	e58d4044 	str	r4, [sp, #68]	; 0x44                          <== NOT EXECUTED
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
   3674c:	12400001 	subne	r0, r0, #1                                  <== NOT EXECUTED
   36750:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
   36754:	1b0079a7 	blne	54df8 <__aeabi_uidiv>                        <== NOT EXECUTED
   36758:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
  /*                                                                  
   * Round up to fill a block because the minimum allocation unit is a block.
   */                                                                 
  fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
  fs->group_inodes =                                                  
    rtems_rfs_rup_quotient (fs->group_inodes,                         
   3675c:	e0020094 	mul	r2, r4, r0                                    <== NOT EXECUTED
                            fs->inodes_per_block) * fs->inodes_per_block;
                                                                      
  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
   36760:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   36764:	e1a03183 	lsl	r3, r3, #3                                    <== NOT EXECUTED
   36768:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Round up to fill a block because the minimum allocation unit is a block.
   */                                                                 
  fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
  fs->group_inodes =                                                  
   3676c:	e58d2040 	str	r2, [sp, #64]	; 0x40                          <== NOT EXECUTED
    rtems_rfs_rup_quotient (fs->group_inodes,                         
                            fs->inodes_per_block) * fs->inodes_per_block;
                                                                      
  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
    fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);  
   36770:	858d3040 	strhi	r3, [sp, #64]	; 0x40                        <== NOT EXECUTED
                                                                      
  fs->max_name_length = config->max_name_length;                      
   36774:	e5973010 	ldr	r3, [r7, #16]                                 <== NOT EXECUTED
  if (!fs->max_name_length)                                           
   36778:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                            fs->inodes_per_block) * fs->inodes_per_block;
                                                                      
  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
    fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);  
                                                                      
  fs->max_name_length = config->max_name_length;                      
   3677c:	e58d3030 	str	r3, [sp, #48]	; 0x30                          <== NOT EXECUTED
  if (!fs->max_name_length)                                           
  {                                                                   
    fs->max_name_length = 512;                                        
   36780:	02833c02 	addeq	r3, r3, #512	; 0x200                        <== NOT EXECUTED
   36784:	058d3030 	streq	r3, [sp, #48]	; 0x30                        <== NOT EXECUTED
   * Check the configuration data.                                    
   */                                                                 
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
                                                                      
  if (config->verbose)                                                
   36788:	e5d73015 	ldrb	r3, [r7, #21]                                <== NOT EXECUTED
   3678c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   36790:	0a00003b 	beq	36884 <rtems_rfs_format+0x38c>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: media size = %" PRIu64 "\n",          
   36794:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
   36798:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3679c:	ebfffde1 	bl	35f28 <rtems_rfs_fs_media_size>                <== NOT EXECUTED
   367a0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   367a4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   367a8:	e59f08d8 	ldr	r0, [pc, #2264]	; 37088 <rtems_rfs_format+0xb90><== NOT EXECUTED
   367ac:	eb002b31 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_fs_media_size (&fs));                           
    printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",        
   367b0:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   367b4:	e59f08d0 	ldr	r0, [pc, #2256]	; 3708c <rtems_rfs_format+0xb94><== NOT EXECUTED
   367b8:	e593101c 	ldr	r1, [r3, #28]                                 <== NOT EXECUTED
   367bc:	eb002b2d 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_fs_media_blocks (&fs));                         
    printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",    
   367c0:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
   367c4:	e59f08c4 	ldr	r0, [pc, #2244]	; 37090 <rtems_rfs_format+0xb98><== NOT EXECUTED
   367c8:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
   367cc:	eb002b29 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_fs_media_block_size (&fs));                     
    printf ("rtems-rfs: format: size = %" PRIu64 "\n",                
   367d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   367d4:	ebfffdcc 	bl	35f0c <rtems_rfs_fs_size>                      <== NOT EXECUTED
   367d8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   367dc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   367e0:	e59f08ac 	ldr	r0, [pc, #2220]	; 37094 <rtems_rfs_format+0xb9c><== NOT EXECUTED
   367e4:	eb002b23 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_fs_size (&fs));                                 
    printf ("rtems-rfs: format: blocks = %zu\n",                      
   367e8:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
   367ec:	e59f08a4 	ldr	r0, [pc, #2212]	; 37098 <rtems_rfs_format+0xba0><== NOT EXECUTED
   367f0:	eb002b20 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_fs_blocks (&fs));                               
    printf ("rtems-rfs: format: block size = %zu\n",                  
   367f4:	e59d1020 	ldr	r1, [sp, #32]                                 <== NOT EXECUTED
   367f8:	e59f089c 	ldr	r0, [pc, #2204]	; 3709c <rtems_rfs_format+0xba4><== NOT EXECUTED
   367fc:	eb002b1d 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_fs_block_size (&fs));                           
    printf ("rtems-rfs: format: bits per block = %u\n",               
   36800:	e59d1020 	ldr	r1, [sp, #32]                                 <== NOT EXECUTED
   36804:	e59f0894 	ldr	r0, [pc, #2196]	; 370a0 <rtems_rfs_format+0xba8><== NOT EXECUTED
   36808:	e1a01181 	lsl	r1, r1, #3                                    <== NOT EXECUTED
   3680c:	eb002b19 	bl	41478 <printf>                                 <== NOT EXECUTED
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
   36810:	e3a01038 	mov	r1, #56	; 0x38                                <== NOT EXECUTED
   36814:	e59f0888 	ldr	r0, [pc, #2184]	; 370a4 <rtems_rfs_format+0xbac><== NOT EXECUTED
   36818:	eb002b16 	bl	41478 <printf>                                 <== NOT EXECUTED
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
   3681c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   36820:	ebffff16 	bl	36480 <rtems_rfs_inode_overhead>               <== NOT EXECUTED
   36824:	e59d2040 	ldr	r2, [sp, #64]	; 0x40                          <== NOT EXECUTED
   36828:	e59d3038 	ldr	r3, [sp, #56]	; 0x38                          <== NOT EXECUTED
   3682c:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
   36830:	e0040392 	mul	r4, r2, r3                                    <== NOT EXECUTED
   36834:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   36838:	eb0079b2 	bl	54f08 <__aeabi_idiv>                           <== NOT EXECUTED
   3683c:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
   36840:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   36844:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36848:	eb007a31 	bl	55114 <__modsi3>                               <== NOT EXECUTED
   3684c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   36850:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36854:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36858:	e59f0848 	ldr	r0, [pc, #2120]	; 370a8 <rtems_rfs_format+0xbb0><== NOT EXECUTED
   3685c:	eb002b05 	bl	41478 <printf>                                 <== NOT EXECUTED
            fs.group_inodes * fs.group_count,                         
            rtems_rfs_inode_overhead (&fs) / 10,                      
            rtems_rfs_inode_overhead (&fs) % 10);                     
    printf ("rtems-rfs: format: groups = %u\n", fs.group_count);      
   36860:	e59d1038 	ldr	r1, [sp, #56]	; 0x38                          <== NOT EXECUTED
   36864:	e59f0840 	ldr	r0, [pc, #2112]	; 370ac <rtems_rfs_format+0xbb4><== NOT EXECUTED
   36868:	eb002b02 	bl	41478 <printf>                                 <== NOT EXECUTED
    printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
   3686c:	e59d103c 	ldr	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   36870:	e59f0838 	ldr	r0, [pc, #2104]	; 370b0 <rtems_rfs_format+0xbb8><== NOT EXECUTED
   36874:	eb002aff 	bl	41478 <printf>                                 <== NOT EXECUTED
    printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
   36878:	e59f0834 	ldr	r0, [pc, #2100]	; 370b4 <rtems_rfs_format+0xbbc><== NOT EXECUTED
   3687c:	e59d1040 	ldr	r1, [sp, #64]	; 0x40                          <== NOT EXECUTED
   36880:	eb002afc 	bl	41478 <printf>                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
   36884:	e28d6018 	add	r6, sp, #24                                   <== NOT EXECUTED
   36888:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3688c:	e59d1020 	ldr	r1, [sp, #32]                                 <== NOT EXECUTED
   36890:	ebfff716 	bl	344f0 <rtems_rfs_buffer_setblksize>            <== NOT EXECUTED
  if (rc > 0)                                                         
   36894:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   36898:	da000004 	ble	368b0 <rtems_rfs_format+0x3b8>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: setting block size failed: %d: %s\n", 
   3689c:	eb003308 	bl	434c4 <strerror>                               <== NOT EXECUTED
   368a0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   368a4:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   368a8:	e59f0808 	ldr	r0, [pc, #2056]	; 370b8 <rtems_rfs_format+0xbc0><== NOT EXECUTED
   368ac:	ea0001ea 	b	3705c <rtems_rfs_format+0xb64>                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   368b0:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);       
   368b4:	e28d80d8 	add	r8, sp, #216	; 0xd8                           <== NOT EXECUTED
   368b8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   368bc:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   368c0:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   368c4:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   368c8:	e5cd40d8 	strb	r4, [sp, #216]	; 0xd8                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   368cc:	e58d40dc 	str	r4, [sp, #220]	; 0xdc                         <== NOT EXECUTED
  handle->buffer = NULL;                                              
   368d0:	e58d40e0 	str	r4, [sp, #224]	; 0xe0                         <== NOT EXECUTED
   368d4:	ebfff781 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
  if (rc > 0)                                                         
   368d8:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   368dc:	da000008 	ble	36904 <rtems_rfs_format+0x40c>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   368e0:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   368e4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   368e8:	ebfffefa 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",  
   368ec:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   368f0:	eb0032f3 	bl	434c4 <strerror>                               <== NOT EXECUTED
   368f4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   368f8:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   368fc:	e59f07b8 	ldr	r0, [pc, #1976]	; 370bc <rtems_rfs_format+0xbc4><== NOT EXECUTED
   36900:	ea00006d 	b	36abc <rtems_rfs_format+0x5c4>                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
   36904:	e59d30e0 	ldr	r3, [sp, #224]	; 0xe0                         <== NOT EXECUTED
   36908:	e593a020 	ldr	sl, [r3, #32]                                 <== NOT EXECUTED
                                                                      
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)           
                                                                      
  memset (sb, 0xff, rtems_rfs_fs_block_size (fs));                    
   3690c:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   36910:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
   36914:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   36918:	eb0026af 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
   3691c:	e3a03028 	mov	r3, #40	; 0x28                                <== NOT EXECUTED
   36920:	e5ca3000 	strb	r3, [sl]                                     <== NOT EXECUTED
   36924:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   36928:	e5ca3001 	strb	r3, [sl, #1]                                 <== NOT EXECUTED
   3692c:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
   36930:	e2833017 	add	r3, r3, #23                                   <== NOT EXECUTED
   36934:	e5ca3002 	strb	r3, [sl, #2]                                 <== NOT EXECUTED
   36938:	e5ca5003 	strb	r5, [sl, #3]                                 <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
   3693c:	e5ca4004 	strb	r4, [sl, #4]                                 <== NOT EXECUTED
   36940:	e5ca4005 	strb	r4, [sl, #5]                                 <== NOT EXECUTED
   36944:	e5ca4006 	strb	r4, [sl, #6]                                 <== NOT EXECUTED
   36948:	e5ca4007 	strb	r4, [sl, #7]                                 <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
   3694c:	e5dd301f 	ldrb	r3, [sp, #31]                                <== NOT EXECUTED
   36950:	e5ca300c 	strb	r3, [sl, #12]                                <== NOT EXECUTED
   36954:	e1dd31be 	ldrh	r3, [sp, #30]                                <== NOT EXECUTED
   36958:	e5ca300d 	strb	r3, [sl, #13]                                <== NOT EXECUTED
   3695c:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   36960:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   36964:	e5ca300e 	strb	r3, [sl, #14]                                <== NOT EXECUTED
   36968:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
   3696c:	e5ca300f 	strb	r3, [sl, #15]                                <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
   36970:	e5dd3023 	ldrb	r3, [sp, #35]	; 0x23                         <== NOT EXECUTED
   36974:	e5ca3008 	strb	r3, [sl, #8]                                 <== NOT EXECUTED
   36978:	e1dd32b2 	ldrh	r3, [sp, #34]	; 0x22                         <== NOT EXECUTED
   3697c:	e5ca3009 	strb	r3, [sl, #9]                                 <== NOT EXECUTED
   36980:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   36984:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   36988:	e5ca300a 	strb	r3, [sl, #10]                                <== NOT EXECUTED
   3698c:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   36990:	e5ca300b 	strb	r3, [sl, #11]                                <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);          
   36994:	e5dd302f 	ldrb	r3, [sp, #47]	; 0x2f                         <== NOT EXECUTED
   36998:	e5ca3010 	strb	r3, [sl, #16]                                <== NOT EXECUTED
   3699c:	e1dd32be 	ldrh	r3, [sp, #46]	; 0x2e                         <== NOT EXECUTED
   369a0:	e5ca3011 	strb	r3, [sl, #17]                                <== NOT EXECUTED
   369a4:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   369a8:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   369ac:	e5ca3012 	strb	r3, [sl, #18]                                <== NOT EXECUTED
   369b0:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   369b4:	e5ca3013 	strb	r3, [sl, #19]                                <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
   369b8:	e5dd3033 	ldrb	r3, [sp, #51]	; 0x33                         <== NOT EXECUTED
   369bc:	e5ca3014 	strb	r3, [sl, #20]                                <== NOT EXECUTED
   369c0:	e1dd33b2 	ldrh	r3, [sp, #50]	; 0x32                         <== NOT EXECUTED
   369c4:	e5ca3015 	strb	r3, [sl, #21]                                <== NOT EXECUTED
   369c8:	e59d3030 	ldr	r3, [sp, #48]	; 0x30                          <== NOT EXECUTED
   369cc:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   369d0:	e5ca3016 	strb	r3, [sl, #22]                                <== NOT EXECUTED
   369d4:	e59d3030 	ldr	r3, [sp, #48]	; 0x30                          <== NOT EXECUTED
   369d8:	e5ca3017 	strb	r3, [sl, #23]                                <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);             
   369dc:	e5dd303b 	ldrb	r3, [sp, #59]	; 0x3b                         <== NOT EXECUTED
   369e0:	e5ca3018 	strb	r3, [sl, #24]                                <== NOT EXECUTED
   369e4:	e1dd33ba 	ldrh	r3, [sp, #58]	; 0x3a                         <== NOT EXECUTED
   369e8:	e5ca3019 	strb	r3, [sl, #25]                                <== NOT EXECUTED
   369ec:	e59d3038 	ldr	r3, [sp, #56]	; 0x38                          <== NOT EXECUTED
   369f0:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   369f4:	e5ca301a 	strb	r3, [sl, #26]                                <== NOT EXECUTED
   369f8:	e59d3038 	ldr	r3, [sp, #56]	; 0x38                          <== NOT EXECUTED
   369fc:	e5ca301b 	strb	r3, [sl, #27]                                <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);      
   36a00:	e5dd303f 	ldrb	r3, [sp, #63]	; 0x3f                         <== NOT EXECUTED
   36a04:	e5ca301c 	strb	r3, [sl, #28]                                <== NOT EXECUTED
   36a08:	e1dd33be 	ldrh	r3, [sp, #62]	; 0x3e                         <== NOT EXECUTED
   36a0c:	e5ca301d 	strb	r3, [sl, #29]                                <== NOT EXECUTED
   36a10:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   36a14:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   36a18:	e5ca301e 	strb	r3, [sl, #30]                                <== NOT EXECUTED
   36a1c:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   36a20:	e5ca301f 	strb	r3, [sl, #31]                                <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
   36a24:	e5dd3043 	ldrb	r3, [sp, #67]	; 0x43                         <== NOT EXECUTED
   36a28:	e5ca3020 	strb	r3, [sl, #32]                                <== NOT EXECUTED
   36a2c:	e1dd34b2 	ldrh	r3, [sp, #66]	; 0x42                         <== NOT EXECUTED
   36a30:	e5ca3021 	strb	r3, [sl, #33]	; 0x21                         <== NOT EXECUTED
   36a34:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
   36a38:	e1a03423 	lsr	r3, r3, #8                                    <== NOT EXECUTED
   36a3c:	e5ca3022 	strb	r3, [sl, #34]	; 0x22                         <== NOT EXECUTED
   36a40:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  rc = rtems_rfs_buffer_handle_release (fs, &handle);                 
   36a44:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
  write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);          
  write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
  write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);             
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);      
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
   36a48:	e5ca3023 	strb	r3, [sl, #35]	; 0x23                         <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  rc = rtems_rfs_buffer_handle_release (fs, &handle);                 
   36a4c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
  write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);          
  write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
  write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);             
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);      
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
   36a50:	e3a03038 	mov	r3, #56	; 0x38                                <== NOT EXECUTED
   36a54:	e5ca4024 	strb	r4, [sl, #36]	; 0x24                         <== NOT EXECUTED
   36a58:	e5ca4025 	strb	r4, [sl, #37]	; 0x25                         <== NOT EXECUTED
   36a5c:	e5ca4026 	strb	r4, [sl, #38]	; 0x26                         <== NOT EXECUTED
   36a60:	e5ca3027 	strb	r3, [sl, #39]	; 0x27                         <== NOT EXECUTED
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
   36a64:	e5cd50d8 	strb	r5, [sp, #216]	; 0xd8                        <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_handle_release (fs, &handle);                 
   36a68:	ebfff6d3 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  if (rc > 0)                                                         
   36a6c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   36a70:	da000008 	ble	36a98 <rtems_rfs_format+0x5a0>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36a74:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36a78:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36a7c:	ebfffe95 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
   36a80:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   36a84:	eb00328e 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36a88:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   36a8c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36a90:	e59f0628 	ldr	r0, [pc, #1576]	; 370c0 <rtems_rfs_format+0xbc8><== NOT EXECUTED
   36a94:	ea000008 	b	36abc <rtems_rfs_format+0x5c4>                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
   36a98:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36a9c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36aa0:	ebfffe8c 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  if (rc > 0)                                                         
   36aa4:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   36aa8:	da0000e2 	ble	36e38 <rtems_rfs_format+0x940>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
   36aac:	eb003284 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36ab0:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36ab4:	e59f0608 	ldr	r0, [pc, #1544]	; 370c4 <rtems_rfs_format+0xbcc><== NOT EXECUTED
   36ab8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   36abc:	eb002a6d 	bl	41478 <printf>                                 <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
   36ac0:	e59f0600 	ldr	r0, [pc, #1536]	; 370c8 <rtems_rfs_format+0xbd0><== NOT EXECUTED
   36ac4:	eb002b10 	bl	4170c <puts>                                   <== NOT EXECUTED
   36ac8:	ea000164 	b	37060 <rtems_rfs_format+0xb68>                  <== NOT EXECUTED
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
   36acc:	e59da03c 	ldr	sl, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   36ad0:	e002049a 	mul	r2, sl, r4                                    <== NOT EXECUTED
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
   36ad4:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
   36ad8:	e2827001 	add	r7, r2, #1                                    <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
    if (!rtems_rfs_write_group (&fs, group,                           
                                config->initialise_inodes, config->verbose))
   36adc:	e5d9c014 	ldrb	ip, [r9, #20]                                <== NOT EXECUTED
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
   36ae0:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
   36ae4:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
    if (!rtems_rfs_write_group (&fs, group,                           
                                config->initialise_inodes, config->verbose))
   36ae8:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
   36aec:	9a000003 	bls	36b00 <rtems_rfs_format+0x608>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
   36af0:	e59f05d4 	ldr	r0, [pc, #1492]	; 370cc <rtems_rfs_format+0xbd4><== NOT EXECUTED
   36af4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36af8:	eb002a5e 	bl	41478 <printf>                                 <== NOT EXECUTED
   36afc:	ea000157 	b	37060 <rtems_rfs_format+0xb68>                  <== NOT EXECUTED
  /*                                                                  
   * Be nice to strange sizes of disks. These are embedded systems after all
   * and nice numbers do not always work out. Let the last block pick up the
   * remainder of the blocks.                                         
   */                                                                 
  if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))           
   36b00:	e087200a 	add	r2, r7, sl                                    <== NOT EXECUTED
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
   36b04:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
  /*                                                                  
   * Be nice to strange sizes of disks. These are embedded systems after all
   * and nice numbers do not always work out. Let the last block pick up the
   * remainder of the blocks.                                         
   */                                                                 
  if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))           
   36b08:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
   36b0c:	8067a003 	rsbhi	sl, r7, r3                                  <== NOT EXECUTED
                                                                      
  if (verbose)                                                        
   36b10:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
   36b14:	159f05b4 	ldrne	r0, [pc, #1460]	; 370d0 <rtems_rfs_format+0xbd8><== NOT EXECUTED
   36b18:	11a01004 	movne	r1, r4                                      <== NOT EXECUTED
   36b1c:	11a02007 	movne	r2, r7                                      <== NOT EXECUTED
   36b20:	11a0300a 	movne	r3, sl                                      <== NOT EXECUTED
   36b24:	1b002a53 	blne	41478 <printf>                               <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n", 
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
   36b28:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
   36b2c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   36b30:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   36b34:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   36b38:	e5cd30d8 	strb	r3, [sp, #216]	; 0xd8                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   36b3c:	e58dc0dc 	str	ip, [sp, #220]	; 0xdc                         <== NOT EXECUTED
  handle->buffer = NULL;                                              
   36b40:	e58dc0e0 	str	ip, [sp, #224]	; 0xe0                         <== NOT EXECUTED
    printf (", blocks");                                              
   36b44:	159f0588 	ldrne	r0, [pc, #1416]	; 370d4 <rtems_rfs_format+0xbdc><== NOT EXECUTED
   36b48:	1b002a4a 	blne	41478 <printf>                               <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the block bitmap using the new buffer.                      
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
   36b4c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36b50:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   36b54:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   36b58:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   36b5c:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
   36b60:	eb001613 	bl	3c3b4 <rtems_rfs_bitmap_open>                  <== NOT EXECUTED
                              group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
   36b64:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   36b68:	da000009 	ble	36b94 <rtems_rfs_format+0x69c>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36b6c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36b70:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36b74:	ebfffe57 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
   36b78:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   36b7c:	eb003250 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36b80:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36b84:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36b88:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   36b8c:	e59f0544 	ldr	r0, [pc, #1348]	; 370d8 <rtems_rfs_format+0xbe0><== NOT EXECUTED
   36b90:	ea000013 	b	36be4 <rtems_rfs_format+0x6ec>                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Force the whole buffer to a known state. The bit map may not occupy the
   * whole block.                                                     
   */                                                                 
  memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
   36b94:	e59d30e0 	ldr	r3, [sp, #224]	; 0xe0                         <== NOT EXECUTED
   36b98:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   36b9c:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   36ba0:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
   36ba4:	eb00260c 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Clear the bitmap.                                                
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
   36ba8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36bac:	eb001612 	bl	3c3fc <rtems_rfs_bitmap_map_clear_all>         <== NOT EXECUTED
  if (rc > 0)                                                         
   36bb0:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   36bb4:	da00000c 	ble	36bec <rtems_rfs_format+0x6f4>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
   36bb8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36bbc:	eb0015ba 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36bc0:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36bc4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36bc8:	ebfffe42 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
   36bcc:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   36bd0:	eb00323b 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36bd4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36bd8:	e59f04fc 	ldr	r0, [pc, #1276]	; 370dc <rtems_rfs_format+0xbe4><== NOT EXECUTED
   36bdc:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36be0:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   36be4:	eb002a23 	bl	41478 <printf>                                 <== NOT EXECUTED
   36be8:	ea00011c 	b	37060 <rtems_rfs_format+0xb68>                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Forced allocation of the block bitmap.                           
   */                                                                 
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
   36bec:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   36bf0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36bf4:	eb00167e 	bl	3c5f4 <rtems_rfs_bitmap_map_set>               <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Forced allocation of the inode bitmap.                           
   */                                                                 
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
   36bf8:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   36bfc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36c00:	eb00167b 	bl	3c5f4 <rtems_rfs_bitmap_map_set>               <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Determine the number of inodes blocks in the group.              
   */                                                                 
  blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
   36c04:	e59d0040 	ldr	r0, [sp, #64]	; 0x40                          <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   36c08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
                                                                      
  /*                                                                  
   * Determine the number of inodes blocks in the group.              
   */                                                                 
  blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
   36c0c:	e59d1044 	ldr	r1, [sp, #68]	; 0x44                          <== NOT EXECUTED
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
   36c10:	12400001 	subne	r0, r0, #1                                  <== NOT EXECUTED
   36c14:	1b007877 	blne	54df8 <__aeabi_uidiv>                        <== NOT EXECUTED
   36c18:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
   36c1c:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
   36c20:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   36c24:	ea000001 	b	36c30 <rtems_rfs_format+0x738>                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Forced allocation of the inode blocks which follow the block bitmap.
   */                                                                 
  for (b = 0; b < blocks; b++)                                        
    rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
   36c28:	eb001671 	bl	3c5f4 <rtems_rfs_bitmap_map_set>               <== NOT EXECUTED
  blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
                                                                      
  /*                                                                  
   * Forced allocation of the inode blocks which follow the block bitmap.
   */                                                                 
  for (b = 0; b < blocks; b++)                                        
   36c2c:	e28bb001 	add	fp, fp, #1                                    <== NOT EXECUTED
   36c30:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
   36c34:	e15b0002 	cmp	fp, r2                                        <== NOT EXECUTED
    rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
   36c38:	e28b1002 	add	r1, fp, #2                                    <== NOT EXECUTED
   36c3c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
                                                                      
  /*                                                                  
   * Forced allocation of the inode blocks which follow the block bitmap.
   */                                                                 
  for (b = 0; b < blocks; b++)                                        
   36c40:	bafffff8 	blt	36c28 <rtems_rfs_format+0x730>                <== NOT EXECUTED
    rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
                                                                      
  /*                                                                  
   * Close the block bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
   36c44:	eb001598 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
  if (rc > 0)                                                         
   36c48:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   36c4c:	da000009 	ble	36c78 <rtems_rfs_format+0x780>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36c50:	e28d10d8 	add	r1, sp, #216	; 0xd8                           <== NOT EXECUTED
   36c54:	e28d0018 	add	r0, sp, #24                                   <== NOT EXECUTED
   36c58:	ebfffe1e 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
   36c5c:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   36c60:	eb003217 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36c64:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36c68:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36c6c:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
   36c70:	e59f0468 	ldr	r0, [pc, #1128]	; 370e0 <rtems_rfs_format+0xbe8><== NOT EXECUTED
   36c74:	eaffffda 	b	36be4 <rtems_rfs_format+0x6ec>                  <== NOT EXECUTED
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
   36c78:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
            group, rc, strerror (rc));                                
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
   36c7c:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
                                                                      
  if (verbose)                                                        
   36c80:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
            group, rc, strerror (rc));                                
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
   36c84:	e5cdc0d8 	strb	ip, [sp, #216]	; 0xd8                        <== NOT EXECUTED
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
   36c88:	159f0454 	ldrne	r0, [pc, #1108]	; 370e4 <rtems_rfs_format+0xbec><== NOT EXECUTED
   36c8c:	1b0029f9 	blne	41478 <printf>                               <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the inode bitmap using the old buffer. Should release any changes.
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
   36c90:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   36c94:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   36c98:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36c9c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   36ca0:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   36ca4:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
   36ca8:	eb0015c1 	bl	3c3b4 <rtems_rfs_bitmap_open>                  <== NOT EXECUTED
                              group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
   36cac:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   36cb0:	da000009 	ble	36cdc <rtems_rfs_format+0x7e4>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36cb4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36cb8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36cbc:	ebfffe05 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
   36cc0:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   36cc4:	eb0031fe 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36cc8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36ccc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36cd0:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   36cd4:	e59f040c 	ldr	r0, [pc, #1036]	; 370e8 <rtems_rfs_format+0xbf0><== NOT EXECUTED
   36cd8:	eaffffc1 	b	36be4 <rtems_rfs_format+0x6ec>                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Force the whole buffer to a known state. The bit map may not occupy the
   * whole block.                                                     
   */                                                                 
  memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
   36cdc:	e59d30e0 	ldr	r3, [sp, #224]	; 0xe0                         <== NOT EXECUTED
   36ce0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   36ce4:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   36ce8:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
   36cec:	eb0025ba 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Clear the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
   36cf0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36cf4:	eb0015c0 	bl	3c3fc <rtems_rfs_bitmap_map_clear_all>         <== NOT EXECUTED
  if (rc > 0)                                                         
   36cf8:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   36cfc:	da00000b 	ble	36d30 <rtems_rfs_format+0x838>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
   36d00:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36d04:	eb001568 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36d08:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36d0c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36d10:	ebfffdf0 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \     
   36d14:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   36d18:	eb0031e9 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36d1c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36d20:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36d24:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   36d28:	e59f03bc 	ldr	r0, [pc, #956]	; 370ec <rtems_rfs_format+0xbf4><== NOT EXECUTED
   36d2c:	eaffffac 	b	36be4 <rtems_rfs_format+0x6ec>                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Close the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
   36d30:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36d34:	eb00155c 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
  if (rc > 0)                                                         
   36d38:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   36d3c:	da000009 	ble	36d68 <rtems_rfs_format+0x870>                <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   36d40:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36d44:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36d48:	ebfffde2 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close inode" \      
   36d4c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   36d50:	eb0031db 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36d54:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36d58:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   36d5c:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   36d60:	e59f0388 	ldr	r0, [pc, #904]	; 370f0 <rtems_rfs_format+0xbf8><== NOT EXECUTED
   36d64:	eaffff9e 	b	36be4 <rtems_rfs_format+0x6ec>                  <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
   36d68:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
   36d6c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   36d70:	159d3010 	ldrne	r3, [sp, #16]                               <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close inode" \      
            " bitmap failed: %d: %s\n", group, rc, strerror (rc));    
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
   36d74:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   36d78:	e5cd20d8 	strb	r2, [sp, #216]	; 0xd8                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
   36d7c:	1283a003 	addne	sl, r3, #3                                  <== NOT EXECUTED
   36d80:	13a07000 	movne	r7, #0                                      <== NOT EXECUTED
   36d84:	1a00001a 	bne	36df4 <rtems_rfs_format+0x8fc>                <== NOT EXECUTED
   36d88:	ea000020 	b	36e10 <rtems_rfs_format+0x918>                  <== NOT EXECUTED
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
   36d8c:	ebfff653 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                            group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
                                            false);                   
      if (rc > 0)                                                     
   36d90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
   36d94:	e28ab001 	add	fp, sl, #1                                    <== NOT EXECUTED
                                            group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
                                            false);                   
      if (rc > 0)                                                     
   36d98:	da00000c 	ble	36dd0 <rtems_rfs_format+0x8d8>                <== NOT EXECUTED
   36d9c:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
      {                                                               
        rtems_rfs_buffer_handle_close (fs, &handle);                  
   36da0:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36da4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36da8:	ebfffdca 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
        printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
   36dac:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   36db0:	eb0031c3 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36db4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36db8:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   36dbc:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   36dc0:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
   36dc4:	e59f0328 	ldr	r0, [pc, #808]	; 370f4 <rtems_rfs_format+0xbfc><== NOT EXECUTED
   36dc8:	eb0029aa 	bl	41478 <printf>                                 <== NOT EXECUTED
   36dcc:	ea0000a3 	b	37060 <rtems_rfs_format+0xb68>                  <== NOT EXECUTED
                                                                      
      /*                                                              
       * Force the whole buffer to a known state. The bit map may not occupy the
       * whole block.                                                 
       */                                                             
      memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
   36dd0:	e59d30e0 	ldr	r3, [sp, #224]	; 0xe0                         <== NOT EXECUTED
   36dd4:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   36dd8:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   36ddc:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
   36de0:	eb00257d 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
      rtems_rfs_buffer_mark_dirty (&handle);                          
   36de4:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
   36de8:	e5cdc0d8 	strb	ip, [sp, #216]	; 0xd8                        <== NOT EXECUTED
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
   36dec:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   36df0:	e1a0a00b 	mov	sl, fp                                        <== NOT EXECUTED
   36df4:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
   36df8:	e157000c 	cmp	r7, ip                                        <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
   36dfc:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   36e00:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36e04:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   36e08:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
   36e0c:	baffffde 	blt	36d8c <rtems_rfs_format+0x894>                <== NOT EXECUTED
                                                                      
      rtems_rfs_buffer_mark_dirty (&handle);                          
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
   36e10:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36e14:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   36e18:	ebfffdae 	bl	364d8 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
  if (rc > 0)                                                         
   36e1c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   36e20:	da000091 	ble	3706c <rtems_rfs_format+0xb74>                <== NOT EXECUTED
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
   36e24:	eb0031a6 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36e28:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   36e2c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36e30:	e59f02c0 	ldr	r0, [pc, #704]	; 370f8 <rtems_rfs_format+0xc00><== NOT EXECUTED
   36e34:	ea000088 	b	3705c <rtems_rfs_format+0xb64>                  <== NOT EXECUTED
    printf (", blocks");                                              
                                                                      
  /*                                                                  
   * Open the block bitmap using the new buffer.                      
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
   36e38:	e28d50c0 	add	r5, sp, #192	; 0xc0                           <== NOT EXECUTED
   36e3c:	e1a09007 	mov	r9, r7                                        <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
   36e40:	e59d3038 	ldr	r3, [sp, #56]	; 0x38                          <== NOT EXECUTED
   36e44:	e5d90015 	ldrb	r0, [r9, #21]                                <== NOT EXECUTED
   36e48:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
   36e4c:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
   36e50:	baffff1d 	blt	36acc <rtems_rfs_format+0x5d4>                <== NOT EXECUTED
    if (!rtems_rfs_write_group (&fs, group,                           
                                config->initialise_inodes, config->verbose))
      return -1;                                                      
                                                                      
  if (config->verbose)                                                
   36e54:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    printf ("\n");                                                    
   36e58:	13a0000a 	movne	r0, #10                                     <== NOT EXECUTED
   36e5c:	1b0029fa 	blne	4164c <putchar>                              <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_close (&fs);                                  
   36e60:	e28d0018 	add	r0, sp, #24                                   <== NOT EXECUTED
   36e64:	ebfff5b4 	bl	3453c <rtems_rfs_buffer_close>                 <== NOT EXECUTED
  if (rc > 0)                                                         
   36e68:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   36e6c:	da000004 	ble	36e84 <rtems_rfs_format+0x98c>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: buffer close failed: %d: %s\n",       
   36e70:	eb003193 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36e74:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36e78:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36e7c:	e59f0278 	ldr	r0, [pc, #632]	; 370fc <rtems_rfs_format+0xc04><== NOT EXECUTED
   36e80:	ea000075 	b	3705c <rtems_rfs_format+0xb64>                  <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  /*                                                                  
   * External API so returns -1.                                      
   */                                                                 
  rc = rtems_rfs_fs_open (name, NULL,                                 
   36e84:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   36e88:	e28dc0e8 	add	ip, sp, #232	; 0xe8                           <== NOT EXECUTED
   36e8c:	e59d000c 	ldr	r0, [sp, #12]                                 <== NOT EXECUTED
   36e90:	e3a02006 	mov	r2, #6                                        <== NOT EXECUTED
   36e94:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
   36e98:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   36e9c:	ebfffc44 	bl	35fb4 <rtems_rfs_fs_open>                      <== NOT EXECUTED
                          RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
                          0, &fs);                                    
  if (rc < 0)                                                         
   36ea0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   36ea4:	aa000008 	bge	36ecc <rtems_rfs_format+0x9d4>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: file system open failed: %d: %s\n",   
   36ea8:	eb001814 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   36eac:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
   36eb0:	eb001812 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   36eb4:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   36eb8:	eb003181 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36ebc:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36ec0:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36ec4:	e59f0234 	ldr	r0, [pc, #564]	; 37100 <rtems_rfs_format+0xc08><== NOT EXECUTED
   36ec8:	ea00005a 	b	37038 <rtems_rfs_format+0xb40>                  <== NOT EXECUTED
            errno, strerror (errno));                                 
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);          
   36ecc:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36ed0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   36ed4:	e28d20e4 	add	r2, sp, #228	; 0xe4                           <== NOT EXECUTED
   36ed8:	eb000303 	bl	37aec <rtems_rfs_inode_alloc>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   36edc:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   36ee0:	da000005 	ble	36efc <rtems_rfs_format+0xa04>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",   
   36ee4:	eb003176 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36ee8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   36eec:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36ef0:	e59f020c 	ldr	r0, [pc, #524]	; 37104 <rtems_rfs_format+0xc0c><== NOT EXECUTED
   36ef4:	eb00295f 	bl	41478 <printf>                                 <== NOT EXECUTED
   36ef8:	ea000019 	b	36f64 <rtems_rfs_format+0xa6c>                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  if (ino != RTEMS_RFS_ROOT_INO)                                      
   36efc:	e59d40e4 	ldr	r4, [sp, #228]	; 0xe4                         <== NOT EXECUTED
   36f00:	e3540001 	cmp	r4, #1                                        <== NOT EXECUTED
   36f04:	0a000005 	beq	36f20 <rtems_rfs_format+0xa28>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
   36f08:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36f0c:	e59f01f4 	ldr	r0, [pc, #500]	; 37108 <rtems_rfs_format+0xc10><== NOT EXECUTED
   36f10:	eb002958 	bl	41478 <printf>                                 <== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
   36f14:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36f18:	ebfffc0a 	bl	35f48 <rtems_rfs_fs_close>                     <== NOT EXECUTED
   36f1c:	ea000046 	b	3703c <rtems_rfs_format+0xb44>                  <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   36f20:	e28d5098 	add	r5, sp, #152	; 0x98                           <== NOT EXECUTED
   36f24:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36f28:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36f2c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   36f30:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   36f34:	eb000292 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   36f38:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   36f3c:	da00000b 	ble	36f70 <rtems_rfs_format+0xa78>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: inode open failed: %d: %s\n",         
   36f40:	eb00315f 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36f44:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   36f48:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36f4c:	e59f01b8 	ldr	r0, [pc, #440]	; 3710c <rtems_rfs_format+0xc14><== NOT EXECUTED
   36f50:	eb002948 	bl	41478 <printf>                                 <== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_group_bitmap_free (fs, true, ino);                      
   36f54:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36f58:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36f5c:	e59d20e4 	ldr	r2, [sp, #228]	; 0xe4                         <== NOT EXECUTED
   36f60:	eb0000c2 	bl	37270 <rtems_rfs_group_bitmap_free>            <== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
   36f64:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36f68:	ebfffbf6 	bl	35f48 <rtems_rfs_fs_close>                     <== NOT EXECUTED
   36f6c:	ea000035 	b	37048 <rtems_rfs_format+0xb50>                  <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, 0,                         
   36f70:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   36f74:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
   36f78:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   36f7c:	e59f218c 	ldr	r2, [pc, #396]	; 37110 <rtems_rfs_format+0xc18><== NOT EXECUTED
   36f80:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
   36f84:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   36f88:	eb0001d4 	bl	376e0 <rtems_rfs_inode_initialise>             <== NOT EXECUTED
                                   (RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
                                    RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
                                   0, 0);                             
  if (rc > 0)                                                         
   36f8c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   36f90:	da000004 	ble	36fa8 <rtems_rfs_format+0xab0>                <== NOT EXECUTED
    printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",   
   36f94:	eb00314a 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36f98:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36f9c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36fa0:	e59f016c 	ldr	r0, [pc, #364]	; 37114 <rtems_rfs_format+0xc1c><== NOT EXECUTED
   36fa4:	eb002933 	bl	41478 <printf>                                 <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);             
   36fa8:	e59dc0e4 	ldr	ip, [sp, #228]	; 0xe4                         <== NOT EXECUTED
   36fac:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36fb0:	e28d1098 	add	r1, sp, #152	; 0x98                           <== NOT EXECUTED
   36fb4:	e59f215c 	ldr	r2, [pc, #348]	; 37118 <rtems_rfs_format+0xc20><== NOT EXECUTED
   36fb8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   36fbc:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   36fc0:	ebfff7f7 	bl	34fa4 <rtems_rfs_dir_add_entry>                <== NOT EXECUTED
  if (rc > 0)                                                         
   36fc4:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   36fc8:	da000004 	ble	36fe0 <rtems_rfs_format+0xae8>                <== NOT EXECUTED
    printf ("rtems-rfs: format: directory add failed: %d: %s\n",      
   36fcc:	eb00313c 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36fd0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36fd4:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   36fd8:	e59f013c 	ldr	r0, [pc, #316]	; 3711c <rtems_rfs_format+0xc24><== NOT EXECUTED
   36fdc:	eb002925 	bl	41478 <printf>                                 <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   36fe0:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   36fe4:	e28d1098 	add	r1, sp, #152	; 0x98                           <== NOT EXECUTED
   36fe8:	eb000242 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   36fec:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   36ff0:	da000004 	ble	37008 <rtems_rfs_format+0xb10>                <== NOT EXECUTED
    printf ("rtems-rfs: format: inode close failed: %d: %s\n",        
   36ff4:	eb003132 	bl	434c4 <strerror>                               <== NOT EXECUTED
   36ff8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   36ffc:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   37000:	e59f0118 	ldr	r0, [pc, #280]	; 37120 <rtems_rfs_format+0xc28><== NOT EXECUTED
   37004:	eb00291b 	bl	41478 <printf>                                 <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_fs_close (fs);                                       
   37008:	e59d00e8 	ldr	r0, [sp, #232]	; 0xe8                         <== NOT EXECUTED
   3700c:	ebfffbcd 	bl	35f48 <rtems_rfs_fs_close>                     <== NOT EXECUTED
  if (rc < 0)                                                         
   37010:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   37014:	aa00000a 	bge	37044 <rtems_rfs_format+0xb4c>                <== NOT EXECUTED
    printf ("rtems-rfs: format: file system close failed: %d: %s\n",  
   37018:	eb0017b8 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3701c:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
   37020:	eb0017b6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   37024:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   37028:	eb003125 	bl	434c4 <strerror>                               <== NOT EXECUTED
   3702c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   37030:	e59f00ec 	ldr	r0, [pc, #236]	; 37124 <rtems_rfs_format+0xc2c><== NOT EXECUTED
   37034:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   37038:	eb00290e 	bl	41478 <printf>                                 <== NOT EXECUTED
   3703c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   37040:	ea000007 	b	37064 <rtems_rfs_format+0xb6c>                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
   37044:	dafffffc 	ble	3703c <rtems_rfs_format+0xb44>                <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",   
   37048:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3704c:	eb00311c 	bl	434c4 <strerror>                               <== NOT EXECUTED
   37050:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   37054:	e59f00cc 	ldr	r0, [pc, #204]	; 37128 <rtems_rfs_format+0xc30><== NOT EXECUTED
   37058:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3705c:	eb002905 	bl	41478 <printf>                                 <== NOT EXECUTED
   37060:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   37064:	e28dd0ec 	add	sp, sp, #236	; 0xec                           <== NOT EXECUTED
   37068:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
   3706c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
   37070:	eaffff72 	b	36e40 <rtems_rfs_format+0x948>                  <== NOT EXECUTED
                                                                      

00035f48 <rtems_rfs_fs_close>: return 0; } int rtems_rfs_fs_close (rtems_rfs_file_system* fs) {
   35f48:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   35f4c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   35f50:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   35f54:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
   35f58:	ea000004 	b	35f70 <rtems_rfs_fs_close+0x28>                 <== NOT EXECUTED
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
   35f5c:	e594101c 	ldr	r1, [r4, #28]                                 <== NOT EXECUTED
   35f60:	e0811005 	add	r1, r1, r5                                    <== NOT EXECUTED
   35f64:	eb00053f 	bl	37468 <rtems_rfs_group_close>                  <== NOT EXECUTED
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
   35f68:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   35f6c:	e2855050 	add	r5, r5, #80	; 0x50                            <== NOT EXECUTED
   35f70:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
   35f74:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
   35f78:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
   35f7c:	bafffff6 	blt	35f5c <rtems_rfs_fs_close+0x14>               <== NOT EXECUTED
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
                                                                      
  rtems_rfs_buffer_close (fs);                                        
   35f80:	ebfff96d 	bl	3453c <rtems_rfs_buffer_close>                 <== NOT EXECUTED
                                                                      
  free (fs);                                                          
   35f84:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   35f88:	ebff45c9 	bl	76b4 <free>                                    <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   35f8c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   35f90:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00035f28 <rtems_rfs_fs_media_size>: uint64_t rtems_rfs_fs_media_size (rtems_rfs_file_system* fs) { uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
   35f28:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
   35f2c:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
   35f30:	e593201c 	ldr	r2, [r3, #28]                                 <== NOT EXECUTED
  return blocks * block_size;                                         
}                                                                     
                                                                      
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
   35f34:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
   35f38:	e0843291 	umull	r3, r4, r1, r2                              <== NOT EXECUTED
  uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
  return media_blocks * media_block_size;                             
}                                                                     
   35f3c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   35f40:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   35f44:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00035fb4 <rtems_rfs_fs_open>: rtems_rfs_fs_open (const char* name, void* user, uint32_t flags, uint32_t max_held_buffers, rtems_rfs_file_system** fs) {
   35fb4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   35fb8:	e24dd03c 	sub	sp, sp, #60	; 0x3c                            <== NOT EXECUTED
   35fbc:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                         
    printf ("rtems-rfs: open: %s\n", name);                           
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
   35fc0:	e3a00080 	mov	r0, #128	; 0x80                               <== NOT EXECUTED
rtems_rfs_fs_open (const char*             name,                      
                   void*                   user,                      
                   uint32_t                flags,                     
                   uint32_t                max_held_buffers,          
                   rtems_rfs_file_system** fs)                        
{                                                                     
   35fc4:	e59d4060 	ldr	r4, [sp, #96]	; 0x60                          <== NOT EXECUTED
   35fc8:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
   35fcc:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   35fd0:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                         
    printf ("rtems-rfs: open: %s\n", name);                           
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
   35fd4:	ebff475d 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (!*fs)                                                           
   35fd8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                         
    printf ("rtems-rfs: open: %s\n", name);                           
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
   35fdc:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
  if (!*fs)                                                           
   35fe0:	1a000002 	bne	35ff0 <rtems_rfs_fs_open+0x3c>                <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: open: no memory for file system data\n");   
    errno = ENOMEM;                                                   
   35fe4:	eb001bc5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   35fe8:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   35fec:	ea0000fe 	b	363ec <rtems_rfs_fs_open+0x438>                 <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
   35ff0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   35ff4:	e3a02080 	mov	r2, #128	; 0x80                               <== NOT EXECUTED
   35ff8:	eb0028f7 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  (*fs)->user = user;                                                 
   35ffc:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
   36000:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);                 
   36004:	e2810060 	add	r0, r1, #96	; 0x60                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36008:	e281b044 	add	fp, r1, #68	; 0x44                            <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   3600c:	e2819040 	add	r9, r1, #64	; 0x40                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36010:	e281a054 	add	sl, r1, #84	; 0x54                            <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36014:	e281e050 	add	lr, r1, #80	; 0x50                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36018:	e281c064 	add	ip, r1, #100	; 0x64                           <== NOT EXECUTED
   3601c:	e2812074 	add	r2, r1, #116	; 0x74                           <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36020:	e2813070 	add	r3, r1, #112	; 0x70                           <== NOT EXECUTED
   36024:	e5810068 	str	r0, [r1, #104]	; 0x68                         <== NOT EXECUTED
                                                                      
  (*fs)->max_held_buffers = max_held_buffers;                         
  (*fs)->buffers_count = 0;                                           
  (*fs)->release_count = 0;                                           
  (*fs)->release_modified_count = 0;                                  
  (*fs)->flags = flags;                                               
   36028:	e5816000 	str	r6, [r1]                                      <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
                                                                      
  (*fs)->user = user;                                                 
   3602c:	e581707c 	str	r7, [r1, #124]	; 0x7c                         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36030:	e581b040 	str	fp, [r1, #64]	; 0x40                          <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36034:	e5819048 	str	r9, [r1, #72]	; 0x48                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36038:	e581a050 	str	sl, [r1, #80]	; 0x50                          <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   3603c:	e581e058 	str	lr, [r1, #88]	; 0x58                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
   36040:	e581c060 	str	ip, [r1, #96]	; 0x60                          <== NOT EXECUTED
   36044:	e5812070 	str	r2, [r1, #112]	; 0x70                         <== NOT EXECUTED
  the_chain->permanent_null = NULL;                                   
  the_chain->last           = _Chain_Head(the_chain);                 
   36048:	e5813078 	str	r3, [r1, #120]	; 0x78                         <== NOT EXECUTED
  rtems_chain_initialize_empty (&(*fs)->buffers);                     
  rtems_chain_initialize_empty (&(*fs)->release);                     
  rtems_chain_initialize_empty (&(*fs)->release_modified);            
  rtems_chain_initialize_empty (&(*fs)->file_shares);                 
                                                                      
  (*fs)->max_held_buffers = max_held_buffers;                         
   3604c:	e581803c 	str	r8, [r1, #60]	; 0x3c                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  the_chain->first          = _Chain_Tail(the_chain);                 
  the_chain->permanent_null = NULL;                                   
   36050:	e5815044 	str	r5, [r1, #68]	; 0x44                          <== NOT EXECUTED
   36054:	e5815054 	str	r5, [r1, #84]	; 0x54                          <== NOT EXECUTED
   36058:	e5815064 	str	r5, [r1, #100]	; 0x64                         <== NOT EXECUTED
   3605c:	e5815074 	str	r5, [r1, #116]	; 0x74                         <== NOT EXECUTED
  (*fs)->buffers_count = 0;                                           
   36060:	e581504c 	str	r5, [r1, #76]	; 0x4c                          <== NOT EXECUTED
  (*fs)->release_count = 0;                                           
   36064:	e581505c 	str	r5, [r1, #92]	; 0x5c                          <== NOT EXECUTED
  (*fs)->release_modified_count = 0;                                  
   36068:	e581506c 	str	r5, [r1, #108]	; 0x6c                         <== NOT EXECUTED
  group_base = 0;                                                     
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
   3606c:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
   36070:	ebfff93b 	bl	34564 <rtems_rfs_buffer_open>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   36074:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   36078:	da000005 	ble	36094 <rtems_rfs_fs_open+0xe0>                <== NOT EXECUTED
  {                                                                   
    free (*fs);                                                       
   3607c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   36080:	ebff458b 	bl	76b4 <free>                                    <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: open: buffer open failed: %d: %s\n",        
              rc, strerror (rc));                                     
    errno = rc;                                                       
   36084:	eb001b9d 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   36088:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   3608c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
   36090:	ea0000e6 	b	36430 <rtems_rfs_fs_open+0x47c>                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
   36094:	e5946000 	ldr	r6, [r4]                                      <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);        
   36098:	e28d7030 	add	r7, sp, #48	; 0x30                            <== NOT EXECUTED
   3609c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   360a0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   360a4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   360a8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   360ac:	e5cd5030 	strb	r5, [sp, #48]	; 0x30                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   360b0:	e58d5034 	str	r5, [sp, #52]	; 0x34                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   360b4:	e58d5038 	str	r5, [sp, #56]	; 0x38                          <== NOT EXECUTED
   360b8:	ebfff988 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
  if (rc > 0)                                                         
   360bc:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   360c0:	ca0000ac 	bgt	36378 <rtems_rfs_fs_open+0x3c4>               <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: request failed%d: %s\n",   
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
   360c4:	e59d3038 	ldr	r3, [sp, #56]	; 0x38                          <== NOT EXECUTED
   360c8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
                                                                      
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))                    
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)      
   360cc:	e5d32003 	ldrb	r2, [r3, #3]                                 <== NOT EXECUTED
   360d0:	e5d31000 	ldrb	r1, [r3]                                     <== NOT EXECUTED
   360d4:	e5d30001 	ldrb	r0, [r3, #1]                                 <== NOT EXECUTED
   360d8:	e1821c01 	orr	r1, r2, r1, lsl #24                           <== NOT EXECUTED
   360dc:	e5d32002 	ldrb	r2, [r3, #2]                                 <== NOT EXECUTED
   360e0:	e1811800 	orr	r1, r1, r0, lsl #16                           <== NOT EXECUTED
   360e4:	e1811402 	orr	r1, r1, r2, lsl #8                            <== NOT EXECUTED
   360e8:	e59f2368 	ldr	r2, [pc, #872]	; 36458 <rtems_rfs_fs_open+0x4a4><== NOT EXECUTED
   360ec:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   360f0:	11a00006 	movne	r0, r6                                      <== NOT EXECUTED
   360f4:	11a01007 	movne	r1, r7                                      <== NOT EXECUTED
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
                                                                      
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))                    
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)      
   360f8:	1a00001d 	bne	36174 <rtems_rfs_fs_open+0x1c0>               <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
   360fc:	e5d3000d 	ldrb	r0, [r3, #13]                                <== NOT EXECUTED
   36100:	e5d3200c 	ldrb	r2, [r3, #12]                                <== NOT EXECUTED
   36104:	e5d3100f 	ldrb	r1, [r3, #15]                                <== NOT EXECUTED
   36108:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
   3610c:	e1800c02 	orr	r0, r0, r2, lsl #24                           <== NOT EXECUTED
   36110:	e5d3200e 	ldrb	r2, [r3, #14]                                <== NOT EXECUTED
   36114:	e1800001 	orr	r0, r0, r1                                    <== NOT EXECUTED
   36118:	e1800402 	orr	r0, r0, r2, lsl #8                            <== NOT EXECUTED
   3611c:	e5860004 	str	r0, [r6, #4]                                  <== NOT EXECUTED
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
   36120:	e5d35009 	ldrb	r5, [r3, #9]                                 <== NOT EXECUTED
   36124:	e5d32008 	ldrb	r2, [r3, #8]                                 <== NOT EXECUTED
   36128:	e5d3100b 	ldrb	r1, [r3, #11]                                <== NOT EXECUTED
   3612c:	e1a05805 	lsl	r5, r5, #16                                   <== NOT EXECUTED
   36130:	e1855c02 	orr	r5, r5, r2, lsl #24                           <== NOT EXECUTED
   36134:	e5d3200a 	ldrb	r2, [r3, #10]                                <== NOT EXECUTED
   36138:	e1855001 	orr	r5, r5, r1                                    <== NOT EXECUTED
   3613c:	e1855402 	orr	r5, r5, r2, lsl #8                            <== NOT EXECUTED
   36140:	e5865008 	str	r5, [r6, #8]                                  <== NOT EXECUTED
}                                                                     
                                                                      
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
   36144:	e596200c 	ldr	r2, [r6, #12]                                 <== NOT EXECUTED
   36148:	e592c01c 	ldr	ip, [r2, #28]                                 <== NOT EXECUTED
   3614c:	e592e024 	ldr	lr, [r2, #36]	; 0x24                          <== NOT EXECUTED
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
                                                                      
  if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))           
   36150:	e0887095 	umull	r7, r8, r5, r0                              <== NOT EXECUTED
}                                                                     
                                                                      
uint64_t                                                              
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)                   
{                                                                     
  uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);  
   36154:	e0821c9e 	umull	r1, r2, lr, ip                              <== NOT EXECUTED
   36158:	e1580002 	cmp	r8, r2                                        <== NOT EXECUTED
   3615c:	8a000002 	bhi	3616c <rtems_rfs_fs_open+0x1b8>               <== NOT EXECUTED
   36160:	1a000006 	bne	36180 <rtems_rfs_fs_open+0x1cc>               <== NOT EXECUTED
   36164:	e1570001 	cmp	r7, r1                                        <== NOT EXECUTED
   36168:	9a000004 	bls	36180 <rtems_rfs_fs_open+0x1cc>               <== NOT EXECUTED
                                                                      
  if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))           
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   3616c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   36170:	e28d1030 	add	r1, sp, #48	; 0x30                            <== NOT EXECUTED
   36174:	ebffff86 	bl	35f94 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
   36178:	e3a08005 	mov	r8, #5                                        <== NOT EXECUTED
   3617c:	ea00007d 	b	36378 <rtems_rfs_fs_open+0x3c4>                 <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
   36180:	e5d31025 	ldrb	r1, [r3, #37]	; 0x25                         <== NOT EXECUTED
   36184:	e5d32024 	ldrb	r2, [r3, #36]	; 0x24                         <== NOT EXECUTED
   36188:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
   3618c:	e5d30027 	ldrb	r0, [r3, #39]	; 0x27                         <== NOT EXECUTED
   36190:	e1811c02 	orr	r1, r1, r2, lsl #24                           <== NOT EXECUTED
   36194:	e5d32026 	ldrb	r2, [r3, #38]	; 0x26                         <== NOT EXECUTED
   36198:	e1811000 	orr	r1, r1, r0                                    <== NOT EXECUTED
   3619c:	e1811402 	orr	r1, r1, r2, lsl #8                            <== NOT EXECUTED
   361a0:	e3510038 	cmp	r1, #56	; 0x38                                <== NOT EXECUTED
   361a4:	1afffff0 	bne	3616c <rtems_rfs_fs_open+0x1b8>               <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);     
   361a8:	e5d32011 	ldrb	r2, [r3, #17]                                <== NOT EXECUTED
   361ac:	e5d30010 	ldrb	r0, [r3, #16]                                <== NOT EXECUTED
   361b0:	e5d3c013 	ldrb	ip, [r3, #19]                                <== NOT EXECUTED
   361b4:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
   361b8:	e1822c00 	orr	r2, r2, r0, lsl #24                           <== NOT EXECUTED
   361bc:	e5d30012 	ldrb	r0, [r3, #18]                                <== NOT EXECUTED
   361c0:	e182200c 	orr	r2, r2, ip                                    <== NOT EXECUTED
   361c4:	e1822400 	orr	r2, r2, r0, lsl #8                            <== NOT EXECUTED
   361c8:	e5862014 	str	r2, [r6, #20]                                 <== NOT EXECUTED
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
   361cc:	e5d32015 	ldrb	r2, [r3, #21]                                <== NOT EXECUTED
   361d0:	e5d30014 	ldrb	r0, [r3, #20]                                <== NOT EXECUTED
   361d4:	e5d3c017 	ldrb	ip, [r3, #23]                                <== NOT EXECUTED
   361d8:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
   361dc:	e1822c00 	orr	r2, r2, r0, lsl #24                           <== NOT EXECUTED
   361e0:	e5d30016 	ldrb	r0, [r3, #22]                                <== NOT EXECUTED
   361e4:	e182200c 	orr	r2, r2, ip                                    <== NOT EXECUTED
   361e8:	e1822400 	orr	r2, r2, r0, lsl #8                            <== NOT EXECUTED
   361ec:	e5862018 	str	r2, [r6, #24]                                 <== NOT EXECUTED
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
   361f0:	e5d30019 	ldrb	r0, [r3, #25]                                <== NOT EXECUTED
   361f4:	e5d32018 	ldrb	r2, [r3, #24]                                <== NOT EXECUTED
   361f8:	e5d3c01b 	ldrb	ip, [r3, #27]                                <== NOT EXECUTED
   361fc:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
   36200:	e1800c02 	orr	r0, r0, r2, lsl #24                           <== NOT EXECUTED
   36204:	e5d3201a 	ldrb	r2, [r3, #26]                                <== NOT EXECUTED
   36208:	e180000c 	orr	r0, r0, ip                                    <== NOT EXECUTED
   3620c:	e1800402 	orr	r0, r0, r2, lsl #8                            <== NOT EXECUTED
  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);   
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
   36210:	e1a02125 	lsr	r2, r5, #2                                    <== NOT EXECUTED
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);     
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
   36214:	e5860020 	str	r0, [r6, #32]                                 <== NOT EXECUTED
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
                                                                      
  fs->block_map_singly_blocks =                                       
    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;                    
  fs->block_map_doubly_blocks =                                       
   36218:	e00a0292 	mul	sl, r2, r2                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);     
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);   
   3621c:	e5d3701d 	ldrb	r7, [r3, #29]                                <== NOT EXECUTED
   36220:	e5d3c01c 	ldrb	ip, [r3, #28]                                <== NOT EXECUTED
   36224:	e5d3e01f 	ldrb	lr, [r3, #31]                                <== NOT EXECUTED
   36228:	e1a07807 	lsl	r7, r7, #16                                   <== NOT EXECUTED
   3622c:	e1877c0c 	orr	r7, r7, ip, lsl #24                           <== NOT EXECUTED
   36230:	e5d3c01e 	ldrb	ip, [r3, #30]                                <== NOT EXECUTED
   36234:	e187700e 	orr	r7, r7, lr                                    <== NOT EXECUTED
   36238:	e187740c 	orr	r7, r7, ip, lsl #8                            <== NOT EXECUTED
   3623c:	e5867024 	str	r7, [r6, #36]	; 0x24                          <== NOT EXECUTED
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
   36240:	e5d38021 	ldrb	r8, [r3, #33]	; 0x21                         <== NOT EXECUTED
   36244:	e5d3c020 	ldrb	ip, [r3, #32]                                <== NOT EXECUTED
   36248:	e5d3e023 	ldrb	lr, [r3, #35]	; 0x23                         <== NOT EXECUTED
   3624c:	e1a08808 	lsl	r8, r8, #16                                   <== NOT EXECUTED
   36250:	e1888c0c 	orr	r8, r8, ip, lsl #24                           <== NOT EXECUTED
   36254:	e5d3c022 	ldrb	ip, [r3, #34]	; 0x22                         <== NOT EXECUTED
   36258:	e188300e 	orr	r3, r8, lr                                    <== NOT EXECUTED
   3625c:	e183340c 	orr	r3, r3, ip, lsl #8                            <== NOT EXECUTED
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
                                                                      
  fs->block_map_singly_blocks =                                       
   36260:	e3a08005 	mov	r8, #5                                        <== NOT EXECUTED
    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;                    
  fs->block_map_doubly_blocks =                                       
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
   36264:	e00c0390 	mul	ip, r0, r3                                    <== NOT EXECUTED
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
                                                                      
  fs->block_map_singly_blocks =                                       
    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;                    
  fs->block_map_doubly_blocks =                                       
   36268:	e00e0a98 	mul	lr, r8, sl                                    <== NOT EXECUTED
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
                                                                      
  fs->block_map_singly_blocks =                                       
   3626c:	e0000298 	mul	r0, r8, r2                                    <== NOT EXECUTED
    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;                    
  fs->block_map_doubly_blocks =                                       
   36270:	e586e038 	str	lr, [r6, #56]	; 0x38                          <== NOT EXECUTED
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
                                                                      
  fs->block_map_singly_blocks =                                       
   36274:	e5860034 	str	r0, [r6, #52]	; 0x34                          <== NOT EXECUTED
    fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;                    
  fs->block_map_doubly_blocks =                                       
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
   36278:	e586c010 	str	ip, [r6, #16]                                 <== NOT EXECUTED
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
   3627c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);     
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);   
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
   36280:	e5863028 	str	r3, [r6, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  fs->blocks_per_block =                                              
   36284:	e5862030 	str	r2, [r6, #48]	; 0x30                          <== NOT EXECUTED
  fs->block_map_doubly_blocks =                                       
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
   36288:	eb007ada 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
  if (fs->group_blocks >                                              
   3628c:	e1570185 	cmp	r7, r5, lsl #3                                <== NOT EXECUTED
  fs->block_map_doubly_blocks =                                       
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
   36290:	e586002c 	str	r0, [r6, #44]	; 0x2c                          <== NOT EXECUTED
   36294:	e28d5030 	add	r5, sp, #48	; 0x30                            <== NOT EXECUTED
                                                                      
  if (fs->group_blocks >                                              
   36298:	8a000007 	bhi	362bc <rtems_rfs_fs_open+0x308>               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
    return EIO;                                                       
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &handle);                        
   3629c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   362a0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   362a4:	ebffff3a 	bl	35f94 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Change the block size to the value in the superblock.            
   */                                                                 
  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
   362a8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   362ac:	e5961008 	ldr	r1, [r6, #8]                                  <== NOT EXECUTED
   362b0:	ebfff88e 	bl	344f0 <rtems_rfs_buffer_setblksize>            <== NOT EXECUTED
  if (rc > 0)                                                         
   362b4:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   362b8:	da000002 	ble	362c8 <rtems_rfs_fs_open+0x314>               <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   362bc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   362c0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   362c4:	ea000023 	b	36358 <rtems_rfs_fs_open+0x3a4>                 <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));    
   362c8:	e5960020 	ldr	r0, [r6, #32]                                 <== NOT EXECUTED
   362cc:	e3a01050 	mov	r1, #80	; 0x50                                <== NOT EXECUTED
   362d0:	ebff4387 	bl	70f4 <calloc>                                  <== NOT EXECUTED
                                                                      
  if (!fs->groups)                                                    
   362d4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   362d8:	13a07000 	movne	r7, #0                                      <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));    
   362dc:	e586001c 	str	r0, [r6, #28]                                 <== NOT EXECUTED
                                                                      
  if (!fs->groups)                                                    
   362e0:	11a05007 	movne	r5, r7                                      <== NOT EXECUTED
   362e4:	1a00001e 	bne	36364 <rtems_rfs_fs_open+0x3b0>               <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
   362e8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   362ec:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   362f0:	ebffff27 	bl	35f94 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
   362f4:	e3a0800c 	mov	r8, #12                                       <== NOT EXECUTED
   362f8:	ea00001e 	b	36378 <rtems_rfs_fs_open+0x3c4>                 <== NOT EXECUTED
   * close everything.                                                
   */                                                                 
  for (group = 0; group < fs->group_count; group++)                   
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
                               rtems_rfs_fs_block (fs, group, 0),     
   362fc:	e5962024 	ldr	r2, [r6, #36]	; 0x24                          <== NOT EXECUTED
   * know how far the initialisation has gone if an error occurs and we need to
   * close everything.                                                
   */                                                                 
  for (group = 0; group < fs->group_count; group++)                   
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
   36300:	e0010592 	mul	r1, r2, r5                                    <== NOT EXECUTED
   36304:	e596301c 	ldr	r3, [r6, #28]                                 <== NOT EXECUTED
   36308:	e0833007 	add	r3, r3, r7                                    <== NOT EXECUTED
   3630c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
   36310:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
   36314:	e5963028 	ldr	r3, [r6, #40]	; 0x28                          <== NOT EXECUTED
   36318:	eb00046c 	bl	374d0 <rtems_rfs_group_open>                   <== NOT EXECUTED
                               rtems_rfs_fs_block (fs, group, 0),     
                               fs->group_blocks,                      
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
   3631c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   * know how far the initialisation has gone if an error occurs and we need to
   * close everything.                                                
   */                                                                 
  for (group = 0; group < fs->group_count; group++)                   
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
   36320:	e2877050 	add	r7, r7, #80	; 0x50                            <== NOT EXECUTED
                               rtems_rfs_fs_block (fs, group, 0),     
                               fs->group_blocks,                      
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
   36324:	da00000d 	ble	36360 <rtems_rfs_fs_open+0x3ac>               <== NOT EXECUTED
   36328:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
   3632c:	e1a0a007 	mov	sl, r7                                        <== NOT EXECUTED
   36330:	ea000004 	b	36348 <rtems_rfs_fs_open+0x394>                 <== NOT EXECUTED
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
   36334:	e596101c 	ldr	r1, [r6, #28]                                 <== NOT EXECUTED
   36338:	e0811007 	add	r1, r1, r7                                    <== NOT EXECUTED
   3633c:	eb000449 	bl	37468 <rtems_rfs_group_close>                  <== NOT EXECUTED
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
   36340:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
   36344:	e2877050 	add	r7, r7, #80	; 0x50                            <== NOT EXECUTED
   36348:	e15a0005 	cmp	sl, r5                                        <== NOT EXECUTED
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
   3634c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
   36350:	bafffff7 	blt	36334 <rtems_rfs_fs_open+0x380>               <== NOT EXECUTED
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
      rtems_rfs_buffer_handle_close (fs, &handle);                    
   36354:	e28d1030 	add	r1, sp, #48	; 0x30                            <== NOT EXECUTED
   36358:	ebffff0d 	bl	35f94 <rtems_rfs_buffer_handle_close>          <== NOT EXECUTED
   3635c:	ea000005 	b	36378 <rtems_rfs_fs_open+0x3c4>                 <== NOT EXECUTED
  /*                                                                  
   * Perform each phase of group initialisation at the same time. This way we
   * know how far the initialisation has gone if an error occurs and we need to
   * close everything.                                                
   */                                                                 
  for (group = 0; group < fs->group_count; group++)                   
   36360:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
   36364:	e5963020 	ldr	r3, [r6, #32]                                 <== NOT EXECUTED
   36368:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
   3636c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
  /*                                                                  
   * Perform each phase of group initialisation at the same time. This way we
   * know how far the initialisation has gone if an error occurs and we need to
   * close everything.                                                
   */                                                                 
  for (group = 0; group < fs->group_count; group++)                   
   36370:	baffffe1 	blt	362fc <rtems_rfs_fs_open+0x348>               <== NOT EXECUTED
   36374:	ea00002f 	b	36438 <rtems_rfs_fs_open+0x484>                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
   36378:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   3637c:	ebfff86e 	bl	3453c <rtems_rfs_buffer_close>                 <== NOT EXECUTED
    free (*fs);                                                       
   36380:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   36384:	ebff44ca 	bl	76b4 <free>                                    <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: open: reading superblock: %d: %s\n",        
              rc, strerror (rc));                                     
    errno = rc;                                                       
   36388:	eb001adc 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3638c:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   36390:	eaffff3d 	b	3608c <rtems_rfs_fs_open+0xd8>                  <== NOT EXECUTED
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)                  
   36394:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   36398:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
   3639c:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
   363a0:	1a000013 	bne	363f4 <rtems_rfs_fs_open+0x440>               <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   363a4:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
   363a8:	e5d23003 	ldrb	r3, [r2, #3]                                 <== NOT EXECUTED
   363ac:	e5d22002 	ldrb	r2, [r2, #2]                                 <== NOT EXECUTED
   363b0:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
  {                                                                   
    mode = rtems_rfs_inode_get_mode (&inode);                         
                                                                      
    if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))                
   363b4:	e59f20a0 	ldr	r2, [pc, #160]	; 3645c <rtems_rfs_fs_open+0x4a8><== NOT EXECUTED
   363b8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   363bc:	0a000002 	beq	363cc <rtems_rfs_fs_open+0x418>               <== NOT EXECUTED
   363c0:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   363c4:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   363c8:	0a000009 	beq	363f4 <rtems_rfs_fs_open+0x440>               <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (*fs, &inode);                            
   363cc:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   363d0:	eb000548 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      rtems_rfs_buffer_close (*fs);                                   
   363d4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   363d8:	ebfff857 	bl	3453c <rtems_rfs_buffer_close>                 <== NOT EXECUTED
      free (*fs);                                                     
   363dc:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   363e0:	ebff44b3 	bl	76b4 <free>                                    <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                     
        printf ("rtems-rfs: open: invalid root inode mode\n");        
      errno = EIO;                                                    
   363e4:	eb001ac5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   363e8:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   363ec:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   363f0:	eaffff25 	b	3608c <rtems_rfs_fs_open+0xd8>                  <== NOT EXECUTED
      return -1;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (*fs, &inode);                           
   363f4:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
   363f8:	eb00053e 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   363fc:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   36400:	da000006 	ble	36420 <rtems_rfs_fs_open+0x46c>               <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
   36404:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   36408:	ebfff84b 	bl	3453c <rtems_rfs_buffer_close>                 <== NOT EXECUTED
    free (*fs);                                                       
   3640c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   36410:	ebff44a7 	bl	76b4 <free>                                    <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
    errno = rc;                                                       
   36414:	eb001ab9 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   36418:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   3641c:	eaffff1a 	b	3608c <rtems_rfs_fs_open+0xd8>                  <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  errno = 0;                                                          
   36420:	eb001ab6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   36424:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   36428:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   3642c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   36430:	e28dd03c 	add	sp, sp, #60	; 0x3c                            <== NOT EXECUTED
   36434:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);  
   36438:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   3643c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   36440:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
   36444:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
   36448:	eb00054d 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   3644c:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   36450:	daffffcf 	ble	36394 <rtems_rfs_fs_open+0x3e0>               <== NOT EXECUTED
   36454:	eaffffea 	b	36404 <rtems_rfs_fs_open+0x450>                 <== NOT EXECUTED
                                                                      

00035f0c <rtems_rfs_fs_size>: #include <rtems/rfs/rtems-rfs-inode.h> #include <rtems/rfs/rtems-rfs-trace.h> uint64_t rtems_rfs_fs_size (rtems_rfs_file_system* fs) {
   35f0c:	e5901008 	ldr	r1, [r0, #8]                                  <== NOT EXECUTED
   35f10:	e5902004 	ldr	r2, [r0, #4]                                  <== NOT EXECUTED
   35f14:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   35f18:	e0843291 	umull	r3, r4, r1, r2                              <== NOT EXECUTED
  uint64_t blocks = rtems_rfs_fs_blocks (fs);                         
  uint64_t block_size = rtems_rfs_fs_block_size (fs);                 
  return blocks * block_size;                                         
}                                                                     
   35f1c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   35f20:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   35f24:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

000372e4 <rtems_rfs_group_bitmap_alloc>: int rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs, rtems_rfs_bitmap_bit goal, bool inode, rtems_rfs_bitmap_bit* result) {
   372e4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_rfs_bitmap_bit bit;                                           
  int                  offset;                                        
  bool                 updown;                                        
  int                  direction;                                     
                                                                      
  if (inode)                                                          
   372e8:	e21290ff 	ands	r9, r2, #255	; 0xff                          <== NOT EXECUTED
  {                                                                   
    size = fs->group_inodes;                                          
   372ec:	15906028 	ldrne	r6, [r0, #40]	; 0x28                        <== NOT EXECUTED
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
   372f0:	05906024 	ldreq	r6, [r0, #36]	; 0x24                        <== NOT EXECUTED
int                                                                   
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,              
                              rtems_rfs_bitmap_bit   goal,            
                              bool                   inode,           
                              rtems_rfs_bitmap_bit*  result)          
{                                                                     
   372f4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  int                  direction;                                     
                                                                      
  if (inode)                                                          
  {                                                                   
    size = fs->group_inodes;                                          
    goal -= RTEMS_RFS_ROOT_INO;                                       
   372f8:	12414001 	subne	r4, r1, #1                                  <== NOT EXECUTED
int                                                                   
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,              
                              rtems_rfs_bitmap_bit   goal,            
                              bool                   inode,           
                              rtems_rfs_bitmap_bit*  result)          
{                                                                     
   372fc:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
   37300:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,              
                              rtems_rfs_bitmap_bit   goal,            
                              bool                   inode,           
                              rtems_rfs_bitmap_bit*  result)          
{                                                                     
   37304:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
   37308:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,              
                              rtems_rfs_bitmap_bit   goal,            
                              bool                   inode,           
                              rtems_rfs_bitmap_bit*  result)          
{                                                                     
   3730c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
   37310:	eb0076b8 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
   37314:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
   37318:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
   3731c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37320:	eb007748 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   37324:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
     * We can start at any location and we move out from that point in each
     * direction. The offset grows until we find a free bit or we hit an end.
     */                                                               
    group = group_start + (direction * offset);                       
    if (offset)                                                       
      bit = direction > 0 ? 0 : size - 1;                             
   37328:	e2466001 	sub	r6, r6, #1                                    <== NOT EXECUTED
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
   3732c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
   37330:	e58d000c 	str	r0, [sp, #12]                                 <== NOT EXECUTED
     * We can start at any location and we move out from that point in each
     * direction. The offset grows until we find a free bit or we hit an end.
     */                                                               
    group = group_start + (direction * offset);                       
    if (offset)                                                       
      bit = direction > 0 ? 0 : size - 1;                             
   37334:	e58d6008 	str	r6, [sp, #8]                                  <== NOT EXECUTED
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
   37338:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
    }                                                                 
                                                                      
   if (inode)                                                         
      bitmap = &fs->groups[group].inode_bitmap;                       
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
   3733c:	e3a0b050 	mov	fp, #80	; 0x50                                <== NOT EXECUTED
   37340:	ea000001 	b	3734c <rtems_rfs_group_bitmap_alloc+0x68>       <== NOT EXECUTED
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
   37344:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   37348:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     * We can start at any location and we move out from that point in each
     * direction. The offset grows until we find a free bit or we hit an end.
     */                                                               
    group = group_start + (direction * offset);                       
   3734c:	e59d6004 	ldr	r6, [sp, #4]                                  <== NOT EXECUTED
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
   37350:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    /*                                                                
     * We can start at any location and we move out from that point in each
     * direction. The offset grows until we find a free bit or we hit an end.
     */                                                               
    group = group_start + (direction * offset);                       
    if (offset)                                                       
   37354:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
   37358:	e5cd2013 	strb	r2, [sp, #19]                                <== NOT EXECUTED
                                                                      
    /*                                                                
     * We can start at any location and we move out from that point in each
     * direction. The offset grows until we find a free bit or we hit an end.
     */                                                               
    group = group_start + (direction * offset);                       
   3735c:	e0266497 	mla	r6, r7, r4, r6                                <== NOT EXECUTED
    if (offset)                                                       
   37360:	0a000003 	beq	37374 <rtems_rfs_group_bitmap_alloc+0x90>     <== NOT EXECUTED
      bit = direction > 0 ? 0 : size - 1;                             
   37364:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   37368:	e3540001 	cmp	r4, #1                                        <== NOT EXECUTED
   3736c:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   37370:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
    /*                                                                
     * If we are still looking up and down and if the group is out of range we
     * have reached one end. Stopping looking up and down and just move in the
     * one direction one group at a time.                             
     */                                                               
    if ((group < 0) || (group >= fs->group_count))                    
   37374:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   37378:	ba000002 	blt	37388 <rtems_rfs_group_bitmap_alloc+0xa4>     <== NOT EXECUTED
   3737c:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
   37380:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
   37384:	ba000005 	blt	373a0 <rtems_rfs_group_bitmap_alloc+0xbc>     <== NOT EXECUTED
    {                                                                 
      if (!updown)                                                    
   37388:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   3738c:	0a000032 	beq	3745c <rtems_rfs_group_bitmap_alloc+0x178>    <== NOT EXECUTED
        break;                                                        
      direction = direction > 0 ? -1 : 1;                             
   37390:	e3540001 	cmp	r4, #1                                        <== NOT EXECUTED
   37394:	13a04001 	movne	r4, #1                                      <== NOT EXECUTED
   37398:	0affffe9 	beq	37344 <rtems_rfs_group_bitmap_alloc+0x60>     <== NOT EXECUTED
   3739c:	eaffffe9 	b	37348 <rtems_rfs_group_bitmap_alloc+0x64>       <== NOT EXECUTED
   373a0:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
   373a4:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
      bitmap = &fs->groups[group].inode_bitmap;                       
   373a8:	102a369b 	mlane	sl, fp, r6, r3                              <== NOT EXECUTED
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
   373ac:	002a369b 	mlaeq	sl, fp, r6, r3                              <== NOT EXECUTED
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
      bitmap = &fs->groups[group].inode_bitmap;                       
   373b0:	128aa02c 	addne	sl, sl, #44	; 0x2c                          <== NOT EXECUTED
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
   373b4:	028aa008 	addeq	sl, sl, #8                                  <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);  
   373b8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   373bc:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
   373c0:	e28d2013 	add	r2, sp, #19                                   <== NOT EXECUTED
   373c4:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
   373c8:	eb00152e 	bl	3c888 <rtems_rfs_bitmap_map_alloc>             <== NOT EXECUTED
    if (rc > 0)                                                       
   373cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   373d0:	ca000022 	bgt	37460 <rtems_rfs_group_bitmap_alloc+0x17c>    <== NOT EXECUTED
      return rc;                                                      
                                                                      
    if (rtems_rfs_fs_release_bitmaps (fs))                            
   373d4:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   373d8:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
   373dc:	059a1000 	ldreq	r1, [sl]                                    <== NOT EXECUTED
   373e0:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
   373e4:	0bfff474 	bleq	345bc <rtems_rfs_buffer_handle_release>      <== NOT EXECUTED
                                                                      
    if (allocated)                                                    
   373e8:	e5dd3013 	ldrb	r3, [sp, #19]                                <== NOT EXECUTED
   373ec:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   373f0:	0a000012 	beq	37440 <rtems_rfs_group_bitmap_alloc+0x15c>    <== NOT EXECUTED
    {                                                                 
      if (inode)                                                      
   373f4:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   373f8:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   373fc:	0a000006 	beq	3741c <rtems_rfs_group_bitmap_alloc+0x138>    <== NOT EXECUTED
        *result = rtems_rfs_group_inode (fs, group, bit);             
   37400:	e5951028 	ldr	r1, [r5, #40]	; 0x28                          <== NOT EXECUTED
   37404:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   37408:	e0223691 	mla	r2, r1, r6, r3                                <== NOT EXECUTED
   3740c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   37410:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   37414:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
   37418:	ea000010 	b	37460 <rtems_rfs_group_bitmap_alloc+0x17c>      <== NOT EXECUTED
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
   3741c:	e3a01050 	mov	r1, #80	; 0x50                                <== NOT EXECUTED
   37420:	e0020691 	mul	r2, r1, r6                                    <== NOT EXECUTED
   37424:	e595101c 	ldr	r1, [r5, #28]                                 <== NOT EXECUTED
   37428:	e7912002 	ldr	r2, [r1, r2]                                  <== NOT EXECUTED
   3742c:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
   37430:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   37434:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   37438:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
   3743c:	ea000007 	b	37460 <rtems_rfs_group_bitmap_alloc+0x17c>      <== NOT EXECUTED
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
                inode ? "inode" : "block", *result);                  
      return 0;                                                       
    }                                                                 
                                                                      
    if (updown)                                                       
   37440:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   37444:	0a000002 	beq	37454 <rtems_rfs_group_bitmap_alloc+0x170>    <== NOT EXECUTED
      direction = direction > 0 ? -1 : 1;                             
   37448:	e3540001 	cmp	r4, #1                                        <== NOT EXECUTED
   3744c:	03e04000 	mvneq	r4, #0                                      <== NOT EXECUTED
   37450:	13a04001 	movne	r4, #1                                      <== NOT EXECUTED
                                                                      
    offset++;                                                         
   37454:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   37458:	eaffffbb 	b	3734c <rtems_rfs_group_bitmap_alloc+0x68>       <== NOT EXECUTED
   3745c:	e3a0001c 	mov	r0, #28                                       <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");  
                                                                      
  return ENOSPC;                                                      
}                                                                     
   37460:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
   37464:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00037270 <rtems_rfs_group_bitmap_free>: int rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs, bool inode, rtems_rfs_bitmap_bit no) {
   37270:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",   
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
   37274:	e21150ff 	ands	r5, r1, #255	; 0xff                          <== NOT EXECUTED
  {                                                                   
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
   37278:	15906028 	ldrne	r6, [r0, #40]	; 0x28                        <== NOT EXECUTED
  }                                                                   
  else                                                                
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
   3727c:	05906024 	ldreq	r6, [r0, #36]	; 0x24                        <== NOT EXECUTED
   37280:	e2427001 	sub	r7, r2, #1                                    <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,               
                             bool                   inode,            
                             rtems_rfs_bitmap_bit   no)               
{                                                                     
   37284:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
   37288:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3728c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   37290:	eb0076d8 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
   37294:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   37298:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
    bitmap = &fs->groups[group].inode_bitmap;                         
   3729c:	13a02050 	movne	r2, #80	; 0x50                              <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
   372a0:	03a02050 	moveq	r2, #80	; 0x50                              <== NOT EXECUTED
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
   372a4:	10253092 	mlane	r5, r2, r0, r3                              <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
   372a8:	00253092 	mlaeq	r5, r2, r0, r3                              <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
   372ac:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   372b0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
   372b4:	1285502c 	addne	r5, r5, #44	; 0x2c                          <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
   372b8:	02855008 	addeq	r5, r5, #8                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
   372bc:	eb007761 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   372c0:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   372c4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   372c8:	eb0014aa 	bl	3c578 <rtems_rfs_bitmap_map_clear>             <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
   372cc:	e5951000 	ldr	r1, [r5]                                      <== NOT EXECUTED
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
   372d0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
   372d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   372d8:	ebfff4b7 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
   372dc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   372e0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000371c0 <rtems_rfs_group_bitmap_test>: int rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs, bool inode, rtems_rfs_bitmap_bit no, bool* state) {
   371c0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
   371c4:	e21150ff 	ands	r5, r1, #255	; 0xff                          <== NOT EXECUTED
int                                                                   
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,               
                             bool                   inode,            
                             rtems_rfs_bitmap_bit   no,               
                             bool*                  state)            
{                                                                     
   371c8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   371cc:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   371d0:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
   371d4:	0a000007 	beq	371f8 <rtems_rfs_group_bitmap_test+0x38>      <== NOT EXECUTED
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
   371d8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   371dc:	da000020 	ble	37264 <rtems_rfs_group_bitmap_test+0xa4>      <== NOT EXECUTED
   371e0:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   371e4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
        return EINVAL;                                                
    no -= RTEMS_RFS_ROOT_INO;                                         
   371e8:	92426001 	subls	r6, r2, #1                                  <== NOT EXECUTED
    size = fs->group_inodes;                                          
   371ec:	95907028 	ldrls	r7, [r0, #40]	; 0x28                        <== NOT EXECUTED
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
   371f0:	9a000004 	bls	37208 <rtems_rfs_group_bitmap_test+0x48>      <== NOT EXECUTED
   371f4:	ea00001a 	b	37264 <rtems_rfs_group_bitmap_test+0xa4>        <== NOT EXECUTED
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
  }                                                                   
  else                                                                
  {                                                                   
    if (no >= rtems_rfs_fs_blocks (fs))                               
   371f8:	e5903004 	ldr	r3, [r0, #4]                                  <== NOT EXECUTED
   371fc:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
   37200:	2a000017 	bcs	37264 <rtems_rfs_group_bitmap_test+0xa4>      <== NOT EXECUTED
        return EINVAL;                                                
    size = fs->group_blocks;                                          
   37204:	e5907024 	ldr	r7, [r0, #36]	; 0x24                          <== NOT EXECUTED
  }                                                                   
                                                                      
  group = no / size;                                                  
   37208:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   3720c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   37210:	eb0076f8 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
   37214:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   37218:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
    bitmap = &fs->groups[group].inode_bitmap;                         
   3721c:	13a02050 	movne	r2, #80	; 0x50                              <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
   37220:	03a02050 	moveq	r2, #80	; 0x50                              <== NOT EXECUTED
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
   37224:	10253092 	mlane	r5, r2, r0, r3                              <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
   37228:	00253092 	mlaeq	r5, r2, r0, r3                              <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
   3722c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37230:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
   37234:	1285502c 	addne	r5, r5, #44	; 0x2c                          <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
   37238:	02855008 	addeq	r5, r5, #8                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
   3723c:	eb007781 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   37240:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   37244:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   37248:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3724c:	eb0014b3 	bl	3c520 <rtems_rfs_bitmap_map_test>              <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
   37250:	e5951000 	ldr	r1, [r5]                                      <== NOT EXECUTED
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
   37254:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
   37258:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3725c:	ebfff4d6 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
                                                                      
  return rc;                                                          
   37260:	ea000000 	b	37268 <rtems_rfs_group_bitmap_test+0xa8>        <== NOT EXECUTED
   37264:	e3a06016 	mov	r6, #22                                       <== NOT EXECUTED
}                                                                     
   37268:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   3726c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00037468 <rtems_rfs_group_close>: return 0; } int rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group) {
   37468:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   3746c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  /*                                                                  
   * We need to close as much as possible and also return any error if one
   * occurs but this may result in one even more important error being lost but
   * we cannot OR the errors together so this is a reasonable compromise.
   */                                                                 
  rc = rtems_rfs_bitmap_close (&group->inode_bitmap);                 
   37470:	e281002c 	add	r0, r1, #44	; 0x2c                            <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{                                                                     
   37474:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  /*                                                                  
   * We need to close as much as possible and also return any error if one
   * occurs but this may result in one even more important error being lost but
   * we cannot OR the errors together so this is a reasonable compromise.
   */                                                                 
  rc = rtems_rfs_bitmap_close (&group->inode_bitmap);                 
   37478:	eb00138b 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   3747c:	e2841044 	add	r1, r4, #68	; 0x44                            <== NOT EXECUTED
   37480:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   37484:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   37488:	ebfff44b 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   3748c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   37490:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   37494:	e5c43044 	strb	r3, [r4, #68]	; 0x44                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   37498:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
  if (rc > 0)                                                         
    result = rc;                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
  if (rc > 0)                                                         
    result = rc;                                                      
  rc = rtems_rfs_bitmap_close (&group->block_bitmap);                 
   3749c:	e2840008 	add	r0, r4, #8                                    <== NOT EXECUTED
   374a0:	eb001381 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   374a4:	e2841020 	add	r1, r4, #32                                   <== NOT EXECUTED
  if (rc > 0)                                                         
   374a8:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   374ac:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   374b0:	d1c75fc7 	bicle	r5, r7, r7, asr #31                         <== NOT EXECUTED
   374b4:	ebfff440 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   374b8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   374bc:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   374c0:	e5c43020 	strb	r3, [r4, #32]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   374c4:	e5843024 	str	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
  rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
  if (rc > 0)                                                         
    result = rc;                                                      
                                                                      
  return result;                                                      
}                                                                     
   374c8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   374cc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

000374d0 <rtems_rfs_group_open>: rtems_rfs_group_open (rtems_rfs_file_system* fs, rtems_rfs_buffer_block base, size_t size, size_t inodes, rtems_rfs_group* group) {
   374d0:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
   374d4:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (base >= rtems_rfs_fs_blocks (fs))                               
   374d8:	e5900004 	ldr	r0, [r0, #4]                                  <== NOT EXECUTED
   374dc:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
rtems_rfs_group_open (rtems_rfs_file_system* fs,                      
                      rtems_rfs_buffer_block base,                    
                      size_t                 size,                    
                      size_t                 inodes,                  
                      rtems_rfs_group*       group)                   
{                                                                     
   374e0:	e1a0c001 	mov	ip, r1                                        <== NOT EXECUTED
   374e4:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   374e8:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
   374ec:	e59d402c 	ldr	r4, [sp, #44]	; 0x2c                          <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (base >= rtems_rfs_fs_blocks (fs))                               
   374f0:	23a0b005 	movcs	fp, #5                                      <== NOT EXECUTED
   374f4:	2a00003a 	bcs	375e4 <rtems_rfs_group_open+0x114>            <== NOT EXECUTED
      printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
              EIO, strerror (EIO));                                   
    return EIO;                                                       
  }                                                                   
                                                                      
  if ((base + size) >= rtems_rfs_fs_blocks (fs))                      
   374f8:	e0823001 	add	r3, r2, r1                                    <== NOT EXECUTED
   374fc:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
    size = rtems_rfs_fs_blocks (fs) - base;                           
   37500:	20617000 	rsbcs	r7, r1, r0                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   37504:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,               
   37508:	e2849008 	add	r9, r4, #8                                    <== NOT EXECUTED
   3750c:	e2848020 	add	r8, r4, #32                                   <== NOT EXECUTED
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                   
    printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
            base, size, inodes);                                      
                                                                      
  group->base = base;                                                 
   37510:	e8840082 	stm	r4, {r1, r7}                                  <== NOT EXECUTED
   37514:	e5c45020 	strb	r5, [r4, #32]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   37518:	e5845024 	str	r5, [r4, #36]	; 0x24                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   3751c:	e5845028 	str	r5, [r4, #40]	; 0x28                          <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,               
   37520:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   37524:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   37528:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   3752c:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   37530:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37534:	eb00139e 	bl	3c3b4 <rtems_rfs_bitmap_open>                  <== NOT EXECUTED
                              &group->block_bitmap_buffer, size,      
                              group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
   37538:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   3753c:	ca000017 	bgt	375a0 <rtems_rfs_group_open+0xd0>             <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,               
   37540:	e594c000 	ldr	ip, [r4]                                      <== NOT EXECUTED
   37544:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
   37548:	e284a044 	add	sl, r4, #68	; 0x44                            <== NOT EXECUTED
   3754c:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
   37550:	31a03007 	movcc	r3, r7                                      <== NOT EXECUTED
   37554:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   37558:	e5c45044 	strb	r5, [r4, #68]	; 0x44                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   3755c:	e5845048 	str	r5, [r4, #72]	; 0x48                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   37560:	e584504c 	str	r5, [r4, #76]	; 0x4c                          <== NOT EXECUTED
   37564:	e284002c 	add	r0, r4, #44	; 0x2c                            <== NOT EXECUTED
   37568:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3756c:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   37570:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37574:	eb00138e 	bl	3c3b4 <rtems_rfs_bitmap_open>                  <== NOT EXECUTED
                              &group->inode_bitmap_buffer, inodes,    
                              group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
   37578:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   3757c:	da00000e 	ble	375bc <rtems_rfs_group_open+0xec>             <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   37580:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   37584:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   37588:	ebfff40b 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   3758c:	e5c45044 	strb	r5, [r4, #68]	; 0x44                         <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   37590:	e5845048 	str	r5, [r4, #72]	; 0x48                          <== NOT EXECUTED
  handle->buffer = NULL;                                              
   37594:	e584504c 	str	r5, [r4, #76]	; 0x4c                          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);  
    rtems_rfs_bitmap_close (&group->block_bitmap);                    
   37598:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   3759c:	eb001342 	bl	3c2ac <rtems_rfs_bitmap_close>                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   375a0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   375a4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   375a8:	ebfff403 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   375ac:	e5845028 	str	r5, [r4, #40]	; 0x28                          <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   375b0:	e5c45020 	strb	r5, [r4, #32]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   375b4:	e5845024 	str	r5, [r4, #36]	; 0x24                          <== NOT EXECUTED
   375b8:	ea000009 	b	375e4 <rtems_rfs_group_open+0x114>              <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  if (rtems_rfs_fs_release_bitmaps (fs))                              
   375bc:	e596b000 	ldr	fp, [r6]                                      <== NOT EXECUTED
   375c0:	e21bb001 	ands	fp, fp, #1                                   <== NOT EXECUTED
   375c4:	11a0b005 	movne	fp, r5                                      <== NOT EXECUTED
   375c8:	1a000005 	bne	375e4 <rtems_rfs_group_open+0x114>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);       
   375cc:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
   375d0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   375d4:	ebfff3f8 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
    rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);       
   375d8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   375dc:	e594102c 	ldr	r1, [r4, #44]	; 0x2c                          <== NOT EXECUTED
   375e0:	ebfff3f5 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   375e4:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   375e8:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  <== NOT EXECUTED
                                                                      

0003712c <rtems_rfs_group_usage>: size_t* blocks, size_t* inodes) { int g; *blocks = 0;
   3712c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_group_usage (rtems_rfs_file_system* fs,                     
                       size_t*                blocks,                 
                       size_t*                inodes)                 
{                                                                     
   37130:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
   37134:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
   37138:	e1a0c003 	mov	ip, r3                                        <== NOT EXECUTED
                       size_t*                inodes)                 
{                                                                     
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
   3713c:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
   37140:	e5906020 	ldr	r6, [r0, #32]                                 <== NOT EXECUTED
   37144:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
   37148:	ea00000e 	b	37188 <rtems_rfs_group_usage+0x5c>              <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
   3714c:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
   37150:	e083300c 	add	r3, r3, ip                                    <== NOT EXECUTED
    *blocks +=                                                        
   37154:	e2838014 	add	r8, r3, #20                                   <== NOT EXECUTED
   37158:	e8980180 	ldm	r8, {r7, r8}                                  <== NOT EXECUTED
   3715c:	e0477008 	sub	r7, r7, r8                                    <== NOT EXECUTED
   37160:	e0855007 	add	r5, r5, r7                                    <== NOT EXECUTED
   37164:	e5815000 	str	r5, [r1]                                      <== NOT EXECUTED
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
      rtems_rfs_bitmap_map_free (&group->block_bitmap);               
    *inodes +=                                                        
   37168:	e2835038 	add	r5, r3, #56	; 0x38                            <== NOT EXECUTED
   3716c:	e8950028 	ldm	r5, {r3, r5}                                  <== NOT EXECUTED
   37170:	e0433005 	sub	r3, r3, r5                                    <== NOT EXECUTED
   37174:	e5925000 	ldr	r5, [r2]                                      <== NOT EXECUTED
   37178:	e0853003 	add	r3, r5, r3                                    <== NOT EXECUTED
   3717c:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
   37180:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
   37184:	e28cc050 	add	ip, ip, #80	; 0x50                            <== NOT EXECUTED
   37188:	e1540006 	cmp	r4, r6                                        <== NOT EXECUTED
   3718c:	e5915000 	ldr	r5, [r1]                                      <== NOT EXECUTED
   37190:	baffffed 	blt	3714c <rtems_rfs_group_usage+0x20>            <== NOT EXECUTED
    *inodes +=                                                        
      rtems_rfs_bitmap_map_size (&group->inode_bitmap) -              
      rtems_rfs_bitmap_map_free (&group->inode_bitmap);               
  }                                                                   
                                                                      
  if (*blocks > rtems_rfs_fs_blocks (fs))                             
   37194:	e5903004 	ldr	r3, [r0, #4]                                  <== NOT EXECUTED
   37198:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
   3719c:	95813000 	strls	r3, [r1]                                    <== NOT EXECUTED
   371a0:	85815000 	strhi	r5, [r1]                                    <== NOT EXECUTED
    *blocks = rtems_rfs_fs_blocks (fs);                               
  if (*inodes > rtems_rfs_fs_inodes (fs))                             
   371a4:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   371a8:	e5921000 	ldr	r1, [r2]                                      <== NOT EXECUTED
    *inodes = rtems_rfs_fs_inodes (fs);                               
                                                                      
  return 0;                                                           
}                                                                     
   371ac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
      rtems_rfs_bitmap_map_free (&group->inode_bitmap);               
  }                                                                   
                                                                      
  if (*blocks > rtems_rfs_fs_blocks (fs))                             
    *blocks = rtems_rfs_fs_blocks (fs);                               
  if (*inodes > rtems_rfs_fs_inodes (fs))                             
   371b0:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
   371b4:	95821000 	strls	r1, [r2]                                    <== NOT EXECUTED
   371b8:	85823000 	strhi	r3, [r2]                                    <== NOT EXECUTED
    *inodes = rtems_rfs_fs_inodes (fs);                               
                                                                      
  return 0;                                                           
}                                                                     
   371bc:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00037aec <rtems_rfs_inode_alloc>: int rtems_rfs_inode_alloc (rtems_rfs_file_system* fs, rtems_rfs_bitmap_bit goal, rtems_rfs_ino* ino) {
   37aec:	e92d4011 	push	{r0, r4, lr}                                 <== NOT EXECUTED
   37af0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  rtems_rfs_bitmap_bit bit;                                           
  int                  rc;                                            
  rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);           
   37af4:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   37af8:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   37afc:	ebfffdf8 	bl	372e4 <rtems_rfs_group_bitmap_alloc>           <== NOT EXECUTED
  *ino = bit;                                                         
   37b00:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   37b04:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   37b08:	e8bd8018 	pop	{r3, r4, pc}                                  <== NOT EXECUTED
                                                                      

000378f8 <rtems_rfs_inode_close>: } int rtems_rfs_inode_close (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
   378f8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                  
    printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
                                                                      
  rc = rtems_rfs_inode_unload (fs, handle, true);                     
   378fc:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_inode_close (rtems_rfs_file_system*  fs,                    
                       rtems_rfs_inode_handle* handle)                
{                                                                     
   37900:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                  
    printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
                                                                      
  rc = rtems_rfs_inode_unload (fs, handle, true);                     
   37904:	ebffffd1 	bl	37850 <rtems_rfs_inode_unload>                 <== NOT EXECUTED
                                                                      
  if ((rc == 0) && (handle->loads > 0))                               
   37908:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   3790c:	1a000003 	bne	37920 <rtems_rfs_inode_close+0x28>            <== NOT EXECUTED
   37910:	e5940024 	ldr	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
   37914:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   37918:	c3a00005 	movgt	r0, #5                                      <== NOT EXECUTED
   3791c:	d3a00000 	movle	r0, #0                                      <== NOT EXECUTED
      printf ("rtems-rfs: inode-close: bad loads number: %d\n",       
              handle->loads);                                         
    rc = EIO;                                                         
  }                                                                   
                                                                      
  handle->ino = 0;                                                    
   37920:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   37924:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   37928:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00037b0c <rtems_rfs_inode_create>: uint16_t mode, uint16_t links, uid_t uid, gid_t gid, rtems_rfs_ino* ino) {
   37b0c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   37b10:	e24dd064 	sub	sp, sp, #100	; 0x64                           <== NOT EXECUTED
   37b14:	e1dda8b8 	ldrh	sl, [sp, #136]	; 0x88                        <== NOT EXECUTED
   37b18:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & RTEMS_RFS_S_IFMT)                                    
   37b1c:	e20a6a0f 	and	r6, sl, #61440	; 0xf000                       <== NOT EXECUTED
                        uint16_t                mode,                 
                        uint16_t                links,                
                        uid_t                   uid,                  
                        gid_t                   gid,                  
                        rtems_rfs_ino*          ino)                  
{                                                                     
   37b20:	e1dd39b0 	ldrh	r3, [sp, #144]	; 0x90                        <== NOT EXECUTED
   37b24:	e1ddc9b4 	ldrh	ip, [sp, #148]	; 0x94                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & RTEMS_RFS_S_IFMT)                                    
   37b28:	e3560a06 	cmp	r6, #24576	; 0x6000                           <== NOT EXECUTED
                        uint16_t                mode,                 
                        uint16_t                links,                
                        uid_t                   uid,                  
                        gid_t                   gid,                  
                        rtems_rfs_ino*          ino)                  
{                                                                     
   37b2c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   37b30:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
   37b34:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   37b38:	e59d5098 	ldr	r5, [sp, #152]	; 0x98                         <== NOT EXECUTED
   37b3c:	e1ddb8bc 	ldrh	fp, [sp, #140]	; 0x8c                        <== NOT EXECUTED
   37b40:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
   37b44:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & RTEMS_RFS_S_IFMT)                                    
   37b48:	0a000009 	beq	37b74 <rtems_rfs_inode_create+0x68>           <== NOT EXECUTED
   37b4c:	ca000003 	bgt	37b60 <rtems_rfs_inode_create+0x54>           <== NOT EXECUTED
   37b50:	e3560a02 	cmp	r6, #8192	; 0x2000                            <== NOT EXECUTED
   37b54:	0a000006 	beq	37b74 <rtems_rfs_inode_create+0x68>           <== NOT EXECUTED
   37b58:	e3560901 	cmp	r6, #16384	; 0x4000                           <== NOT EXECUTED
   37b5c:	ea000002 	b	37b6c <rtems_rfs_inode_create+0x60>             <== NOT EXECUTED
   37b60:	e3560902 	cmp	r6, #32768	; 0x8000                           <== NOT EXECUTED
   37b64:	0a000002 	beq	37b74 <rtems_rfs_inode_create+0x68>           <== NOT EXECUTED
   37b68:	e3560a0a 	cmp	r6, #40960	; 0xa000                           <== NOT EXECUTED
   37b6c:	13a09016 	movne	r9, #22                                     <== NOT EXECUTED
   37b70:	1a000077 	bne	37d54 <rtems_rfs_inode_create+0x248>          <== NOT EXECUTED
      break;                                                          
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, parent, ino);                       
   37b74:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37b78:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   37b7c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   37b80:	ebffffd9 	bl	37aec <rtems_rfs_inode_alloc>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   37b84:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37b88:	ca000071 	bgt	37d54 <rtems_rfs_inode_create+0x248>          <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, *ino, &inode, true);                 
   37b8c:	e28d7014 	add	r7, sp, #20                                   <== NOT EXECUTED
   37b90:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37b94:	e5951000 	ldr	r1, [r5]                                      <== NOT EXECUTED
   37b98:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   37b9c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   37ba0:	ebffff77 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   37ba4:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37ba8:	ca000066 	bgt	37d48 <rtems_rfs_inode_create+0x23c>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);    
   37bac:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
   37bb0:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   37bb4:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
   37bb8:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   37bbc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   37bc0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37bc4:	ebfffec5 	bl	376e0 <rtems_rfs_inode_initialise>             <== NOT EXECUTED
  if (rc > 0)                                                         
   37bc8:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37bcc:	da000003 	ble	37be0 <rtems_rfs_inode_create+0xd4>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   37bd0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37bd4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37bd8:	ebffff46 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   37bdc:	ea000059 	b	37d48 <rtems_rfs_inode_create+0x23c>            <== NOT EXECUTED
  /*                                                                  
   * Only handle the specifics of a directory. Let caller handle the others.
   *                                                                  
   * The inode delete will free the inode.                            
   */                                                                 
  if (RTEMS_RFS_S_ISDIR (mode))                                       
   37be0:	e3560901 	cmp	r6, #16384	; 0x4000                           <== NOT EXECUTED
   37be4:	1a000011 	bne	37c30 <rtems_rfs_inode_create+0x124>          <== NOT EXECUTED
  {                                                                   
    rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);          
   37be8:	e595c000 	ldr	ip, [r5]                                      <== NOT EXECUTED
   37bec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37bf0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37bf4:	e59f2164 	ldr	r2, [pc, #356]	; 37d60 <rtems_rfs_inode_create+0x254><== NOT EXECUTED
   37bf8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   37bfc:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37c00:	ebfff4e7 	bl	34fa4 <rtems_rfs_dir_add_entry>                <== NOT EXECUTED
    if (rc == 0)                                                      
   37c04:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37c08:	1a000006 	bne	37c28 <rtems_rfs_inode_create+0x11c>          <== NOT EXECUTED
      rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);     
   37c0c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37c10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37c14:	e59f2148 	ldr	r2, [pc, #328]	; 37d64 <rtems_rfs_inode_create+0x258><== NOT EXECUTED
   37c18:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   37c1c:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
   37c20:	ebfff4df 	bl	34fa4 <rtems_rfs_dir_add_entry>                <== NOT EXECUTED
   37c24:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
    if (rc > 0)                                                       
   37c28:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
   37c2c:	ca000007 	bgt	37c50 <rtems_rfs_inode_create+0x144>          <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
   37c30:	e28d703c 	add	r7, sp, #60	; 0x3c                            <== NOT EXECUTED
   37c34:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   37c38:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37c3c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   37c40:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   37c44:	ebffff4e 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   37c48:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37c4c:	da000006 	ble	37c6c <rtems_rfs_inode_create+0x160>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
   37c50:	e28d5014 	add	r5, sp, #20                                   <== NOT EXECUTED
   37c54:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37c58:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37c5c:	ebffff7b 	bl	37a50 <rtems_rfs_inode_delete>                 <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
   37c60:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37c64:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37c68:	ea00002e 	b	37d28 <rtems_rfs_inode_create+0x21c>            <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
   37c6c:	e595c000 	ldr	ip, [r5]                                      <== NOT EXECUTED
   37c70:	e99d000c 	ldmib	sp, {r2, r3}                                <== NOT EXECUTED
   37c74:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37c78:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37c7c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37c80:	ebfff4c7 	bl	34fa4 <rtems_rfs_dir_add_entry>                <== NOT EXECUTED
  if (rc > 0)                                                         
   37c84:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37c88:	da000009 	ble	37cb4 <rtems_rfs_inode_create+0x1a8>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
   37c8c:	e28d5014 	add	r5, sp, #20                                   <== NOT EXECUTED
   37c90:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37c94:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37c98:	ebffff6c 	bl	37a50 <rtems_rfs_inode_delete>                 <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
   37c9c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37ca0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37ca4:	ebffff13 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &parent_inode);                        
   37ca8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37cac:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37cb0:	ea00001c 	b	37d28 <rtems_rfs_inode_create+0x21c>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the node is a directory update the parent link count as the   
   * new directory has the '..' link that points to the parent.       
   */                                                                 
  if (RTEMS_RFS_S_ISDIR (mode))                                       
   37cb4:	e3560901 	cmp	r6, #16384	; 0x4000                           <== NOT EXECUTED
   37cb8:	1a00000f 	bne	37cfc <rtems_rfs_inode_create+0x1f0>          <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   37cbc:	e59d2048 	ldr	r2, [sp, #72]	; 0x48                          <== NOT EXECUTED
   37cc0:	e5d21000 	ldrb	r1, [r2]                                     <== NOT EXECUTED
   37cc4:	e5d23001 	ldrb	r3, [r2, #1]                                 <== NOT EXECUTED
   37cc8:	e1833401 	orr	r3, r3, r1, lsl #8                            <== NOT EXECUTED
  if (links == 0xffff)                                                
   37ccc:	e59f1094 	ldr	r1, [pc, #148]	; 37d68 <rtems_rfs_inode_create+0x25c><== NOT EXECUTED
   37cd0:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   37cd4:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
    rtems_rfs_inode_set_links (&parent_inode,                         
   37cd8:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   37cdc:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
 * @prarm links The links.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
   37ce0:	e1a01c23 	lsr	r1, r3, #24                                   <== NOT EXECUTED
   37ce4:	e5c21000 	strb	r1, [r2]                                     <== NOT EXECUTED
   37ce8:	e59d2048 	ldr	r2, [sp, #72]	; 0x48                          <== NOT EXECUTED
   37cec:	e1a03823 	lsr	r3, r3, #16                                   <== NOT EXECUTED
   37cf0:	e5c23001 	strb	r3, [r2, #1]                                 <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   37cf4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   37cf8:	e5cd304c 	strb	r3, [sp, #76]	; 0x4c                         <== NOT EXECUTED
                               rtems_rfs_inode_get_links (&parent_inode) + 1);
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
   37cfc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37d00:	e28d103c 	add	r1, sp, #60	; 0x3c                            <== NOT EXECUTED
   37d04:	ebfffefb 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   37d08:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37d0c:	e28d6014 	add	r6, sp, #20                                   <== NOT EXECUTED
   37d10:	da000006 	ble	37d30 <rtems_rfs_inode_create+0x224>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
   37d14:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   37d18:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37d1c:	ebffff4b 	bl	37a50 <rtems_rfs_inode_delete>                 <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
   37d20:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37d24:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   37d28:	ebfffef2 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    return rc;                                                        
   37d2c:	ea000008 	b	37d54 <rtems_rfs_inode_create+0x248>            <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   37d30:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   37d34:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37d38:	ebfffeee 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   37d3c:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   37d40:	d3a09000 	movle	r9, #0                                      <== NOT EXECUTED
   37d44:	da000002 	ble	37d54 <rtems_rfs_inode_create+0x248>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
   37d48:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37d4c:	e5951000 	ldr	r1, [r5]                                      <== NOT EXECUTED
   37d50:	ebffff3b 	bl	37a44 <rtems_rfs_inode_free>                   <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   37d54:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   37d58:	e28dd064 	add	sp, sp, #100	; 0x64                           <== NOT EXECUTED
   37d5c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00037a50 <rtems_rfs_inode_delete>: } int rtems_rfs_inode_delete (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
   37a50:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))                 
    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",    
           rtems_rfs_inode_ino (handle),                              
           rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");        
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
   37a54:	e591300c 	ldr	r3, [r1, #12]                                 <== NOT EXECUTED
   37a58:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_inode_delete (rtems_rfs_file_system*  fs,                   
                        rtems_rfs_inode_handle* handle)               
{                                                                     
   37a5c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   37a60:	e24dd050 	sub	sp, sp, #80	; 0x50                            <== NOT EXECUTED
   37a64:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))                 
    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",    
           rtems_rfs_inode_ino (handle),                              
           rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");        
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
   37a68:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
   37a6c:	0a00001c 	beq	37ae4 <rtems_rfs_inode_delete+0x94>           <== NOT EXECUTED
    rtems_rfs_block_map map;                                          
                                                                      
    /*                                                                
     * Free the ino number.                                           
     */                                                               
    rc = rtems_rfs_inode_free (fs, handle->ino);                      
   37a70:	e5911008 	ldr	r1, [r1, #8]                                  <== NOT EXECUTED
   37a74:	ebfffff2 	bl	37a44 <rtems_rfs_inode_free>                   <== NOT EXECUTED
    if (rc > 0)                                                       
   37a78:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   37a7c:	ca000018 	bgt	37ae4 <rtems_rfs_inode_delete+0x94>           <== NOT EXECUTED
      return rc;                                                      
                                                                      
    /*                                                                
     * Free the blocks the inode may have attached.                   
     */                                                               
    rc = rtems_rfs_block_map_open (fs, handle, &map);                 
   37a80:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   37a84:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   37a88:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   37a8c:	ebfff203 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
    if (rc == 0)                                                      
   37a90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      return rc;                                                      
                                                                      
    /*                                                                
     * Free the blocks the inode may have attached.                   
     */                                                               
    rc = rtems_rfs_block_map_open (fs, handle, &map);                 
   37a94:	e1a0600d 	mov	r6, sp                                        <== NOT EXECUTED
    if (rc == 0)                                                      
   37a98:	1a000011 	bne	37ae4 <rtems_rfs_inode_delete+0x94>           <== NOT EXECUTED
    {                                                                 
      int rrc;                                                        
      rrc = rtems_rfs_block_map_free_all (fs, &map);                  
   37a9c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   37aa0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   37aa4:	ebfff057 	bl	33c08 <rtems_rfs_block_map_free_all>           <== NOT EXECUTED
      rc = rtems_rfs_block_map_close (fs, &map);                      
   37aa8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   37aac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   37ab0:	ebfff188 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
      if (rc > 0)                                                     
        rrc = rc;                                                     
      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);              
   37ab4:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   37ab8:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
   37abc:	e594000c 	ldr	r0, [r4, #12]                                 <== NOT EXECUTED
   37ac0:	eb002245 	bl	403dc <memset>                                 <== NOT EXECUTED
      rtems_rfs_buffer_mark_dirty (&handle->buffer);                  
   37ac4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   37ac8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   37acc:	e5e13010 	strb	r3, [r1, #16]!                               <== NOT EXECUTED
      /*                                                              
       * Do the release here to avoid the ctime field being set on a  
       * close. Also if there loads is greater then one then other loads
       * active. Forcing the loads count to 0.                        
       */                                                             
      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);     
   37ad0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   37ad4:	ebfff2b8 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
      handle->loads = 0;                                              
   37ad8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
      handle->node = NULL;                                            
   37adc:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
       * Do the release here to avoid the ctime field being set on a  
       * close. Also if there loads is greater then one then other loads
       * active. Forcing the loads count to 0.                        
       */                                                             
      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);     
      handle->loads = 0;                                              
   37ae0:	e5843024 	str	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
  return rc;                                                          
}                                                                     
   37ae4:	e28dd050 	add	sp, sp, #80	; 0x50                            <== NOT EXECUTED
   37ae8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00037a44 <rtems_rfs_inode_free>: } int rtems_rfs_inode_free (rtems_rfs_file_system* fs, rtems_rfs_ino ino) {
   37a44:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  rtems_rfs_bitmap_bit bit;                                           
  bit = ino;                                                          
  return rtems_rfs_group_bitmap_free (fs, true, bit);                 
   37a48:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   37a4c:	eafffe07 	b	37270 <rtems_rfs_group_bitmap_free>             <== NOT EXECUTED
                                                                      

000375ec <rtems_rfs_inode_get_size>: } rtems_rfs_pos rtems_rfs_inode_get_size (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
   375ec:	e92d4003 	push	{r0, r1, lr}                                 <== NOT EXECUTED
 * @return uint32_t The block count.                                  
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)      
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->block_count);             
   375f0:	e591200c 	ldr	r2, [r1, #12]                                 <== NOT EXECUTED
   375f4:	e282300c 	add	r3, r2, #12                                   <== NOT EXECUTED
  rtems_rfs_block_size size;                                          
  size.count = rtems_rfs_inode_get_block_count (handle);              
   375f8:	e5d31003 	ldrb	r1, [r3, #3]                                 <== NOT EXECUTED
   375fc:	e5d2c00c 	ldrb	ip, [r2, #12]                                <== NOT EXECUTED
   37600:	e5d3e001 	ldrb	lr, [r3, #1]                                 <== NOT EXECUTED
   37604:	e181cc0c 	orr	ip, r1, ip, lsl #24                           <== NOT EXECUTED
   37608:	e5d31002 	ldrb	r1, [r3, #2]                                 <== NOT EXECUTED
   3760c:	e18c380e 	orr	r3, ip, lr, lsl #16                           <== NOT EXECUTED
   37610:	e1833401 	orr	r3, r3, r1, lsl #8                            <== NOT EXECUTED
   37614:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  size.offset = rtems_rfs_inode_get_block_offset (handle);            
   37618:	e5d2300b 	ldrb	r3, [r2, #11]                                <== NOT EXECUTED
   3761c:	e5d2200a 	ldrb	r2, [r2, #10]                                <== NOT EXECUTED
  return rtems_rfs_block_get_size (fs, &size);                        
   37620:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
rtems_rfs_inode_get_size (rtems_rfs_file_system*  fs,                 
                          rtems_rfs_inode_handle* handle)             
{                                                                     
  rtems_rfs_block_size size;                                          
  size.count = rtems_rfs_inode_get_block_count (handle);              
  size.offset = rtems_rfs_inode_get_block_offset (handle);            
   37624:	e1833402 	orr	r3, r3, r2, lsl #8                            <== NOT EXECUTED
   37628:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
  return rtems_rfs_block_get_size (fs, &size);                        
   3762c:	ebffeff2 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
}                                                                     
   37630:	e8bd800c 	pop	{r2, r3, pc}                                  <== NOT EXECUTED
                                                                      

000376e0 <rtems_rfs_inode_initialise>: rtems_rfs_inode_initialise (rtems_rfs_inode_handle* handle, uint16_t links, uint16_t mode, uid_t uid, gid_t gid) {
   376e0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   376e4:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
 * @prarm links The links.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
   376e8:	e590400c 	ldr	r4, [r0, #12]                                 <== NOT EXECUTED
   376ec:	e1a05c21 	lsr	r5, r1, #24                                   <== NOT EXECUTED
   376f0:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
   376f4:	e1dd00bc 	ldrh	r0, [sp, #12]                                <== NOT EXECUTED
   376f8:	e5c45000 	strb	r5, [r4]                                     <== NOT EXECUTED
   376fc:	e59c400c 	ldr	r4, [ip, #12]                                 <== NOT EXECUTED
   37700:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
   37704:	e5c41001 	strb	r1, [r4, #1]                                 <== NOT EXECUTED
 * @prarm flags The flags.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_flags (rtems_rfs_inode_handle* handle, uint16_t flags)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->flags, flags);                  
   37708:	e59c400c 	ldr	r4, [ip, #12]                                 <== NOT EXECUTED
   3770c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   37710:	e5c41008 	strb	r1, [r4, #8]                                 <== NOT EXECUTED
   37714:	e59c400c 	ldr	r4, [ip, #12]                                 <== NOT EXECUTED
   37718:	e5c41009 	strb	r1, [r4, #9]                                 <== NOT EXECUTED
   3771c:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
 * @prarm mode The mode.                                              
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->mode, mode);                    
   37720:	e59c400c 	ldr	r4, [ip, #12]                                 <== NOT EXECUTED
   37724:	e1a05c22 	lsr	r5, r2, #24                                   <== NOT EXECUTED
   37728:	e5c45002 	strb	r5, [r4, #2]                                 <== NOT EXECUTED
   3772c:	e59c400c 	ldr	r4, [ip, #12]                                 <== NOT EXECUTED
   37730:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
   37734:	e5c42003 	strb	r2, [r4, #3]                                 <== NOT EXECUTED
   37738:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
   3773c:	e1a03823 	lsr	r3, r3, #16                                   <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,          
                             uint16_t uid, uint16_t gid)              
{                                                                     
  rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
   37740:	e59c200c 	ldr	r2, [ip, #12]                                 <== NOT EXECUTED
   37744:	e1830800 	orr	r0, r3, r0, lsl #16                           <== NOT EXECUTED
   37748:	e1a04c20 	lsr	r4, r0, #24                                   <== NOT EXECUTED
   3774c:	e5c24004 	strb	r4, [r2, #4]                                 <== NOT EXECUTED
   37750:	e59c200c 	ldr	r2, [ip, #12]                                 <== NOT EXECUTED
   37754:	e1a04820 	lsr	r4, r0, #16                                   <== NOT EXECUTED
   37758:	e5c24005 	strb	r4, [r2, #5]                                 <== NOT EXECUTED
   3775c:	e59c200c 	ldr	r2, [ip, #12]                                 <== NOT EXECUTED
   37760:	e1a00420 	lsr	r0, r0, #8                                    <== NOT EXECUTED
   37764:	e5c20006 	strb	r0, [r2, #6]                                 <== NOT EXECUTED
   37768:	e59c200c 	ldr	r2, [ip, #12]                                 <== NOT EXECUTED
   3776c:	e5c23007 	strb	r3, [r2, #7]                                 <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,     
                                  uint16_t                block_offset)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);    
   37770:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   37774:	e5c3100a 	strb	r1, [r3, #10]                                <== NOT EXECUTED
   37778:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   3777c:	e5c3100b 	strb	r1, [r3, #11]                                <== NOT EXECUTED
 * @param block_count The block count.                                
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->block_count, block_count);      
   37780:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   37784:	e5c3100c 	strb	r1, [r3, #12]                                <== NOT EXECUTED
   37788:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   3778c:	e5c3100d 	strb	r1, [r3, #13]                                <== NOT EXECUTED
   37790:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   37794:	e5c3100e 	strb	r1, [r3, #14]                                <== NOT EXECUTED
   37798:	e59c200c 	ldr	r2, [ip, #12]                                 <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   3779c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
 * @param block_count The block count.                                
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->block_count, block_count);      
   377a0:	e5c2100f 	strb	r1, [r2, #15]                                <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   377a4:	e5cc3010 	strb	r3, [ip, #16]                                <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   377a8:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
 * @param bno The block number.                                       
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
   377ac:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   377b0:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   377b4:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
   377b8:	e5c3001c 	strb	r0, [r3, #28]                                <== NOT EXECUTED
   377bc:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   377c0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   377c4:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
   377c8:	e5c3201d 	strb	r2, [r3, #29]                                <== NOT EXECUTED
   377cc:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   377d0:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
   377d4:	e5c3001e 	strb	r0, [r3, #30]                                <== NOT EXECUTED
   377d8:	e59c300c 	ldr	r3, [ip, #12]                                 <== NOT EXECUTED
   377dc:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   377e0:	e2811004 	add	r1, r1, #4                                    <== NOT EXECUTED
  rtems_rfs_inode_set_flags (handle, 0);                              
  rtems_rfs_inode_set_mode (handle,  mode);                           
  rtems_rfs_inode_set_uid_gid (handle, uid, gid);                     
  rtems_rfs_inode_set_block_offset (handle, 0);                       
  rtems_rfs_inode_set_block_count (handle, 0);                        
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
   377e4:	e3510014 	cmp	r1, #20                                       <== NOT EXECUTED
 * @param bno The block number.                                       
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
   377e8:	e5c3001f 	strb	r0, [r3, #31]                                <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   377ec:	e5cc4010 	strb	r4, [ip, #16]                                <== NOT EXECUTED
   377f0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   377f4:	1affffed 	bne	377b0 <rtems_rfs_inode_initialise+0xd0>       <== NOT EXECUTED
 * @param block_count The last map block number.                      
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
   377f8:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   377fc:	e5c12030 	strb	r2, [r1, #48]	; 0x30                         <== NOT EXECUTED
   37800:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   37804:	e5c12031 	strb	r2, [r1, #49]	; 0x31                         <== NOT EXECUTED
   37808:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   3780c:	e5c12032 	strb	r2, [r1, #50]	; 0x32                         <== NOT EXECUTED
   37810:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   37814:	e5c12033 	strb	r2, [r1, #51]	; 0x33                         <== NOT EXECUTED
 * @param block_count The last data block number.                     
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
   37818:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   3781c:	e5c12034 	strb	r2, [r1, #52]	; 0x34                         <== NOT EXECUTED
   37820:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   37824:	e5c12035 	strb	r2, [r1, #53]	; 0x35                         <== NOT EXECUTED
   37828:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
   3782c:	e5c12036 	strb	r2, [r1, #54]	; 0x36                         <== NOT EXECUTED
   37830:	e59c000c 	ldr	r0, [ip, #12]                                 <== NOT EXECUTED
    rtems_rfs_inode_set_block (handle, b, 0);                         
  rtems_rfs_inode_set_last_map_block (handle, 0);                     
  rtems_rfs_inode_set_last_data_block (handle, 0);                    
  return rtems_rfs_inode_time_stamp_now (handle, true, true);         
   37834:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   37838:	e5c02037 	strb	r2, [r0, #55]	; 0x37                         <== NOT EXECUTED
   3783c:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
   37840:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   37844:	e5cc3010 	strb	r3, [ip, #16]                                <== NOT EXECUTED
}                                                                     
   37848:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
  rtems_rfs_inode_set_block_count (handle, 0);                        
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
    rtems_rfs_inode_set_block (handle, b, 0);                         
  rtems_rfs_inode_set_last_map_block (handle, 0);                     
  rtems_rfs_inode_set_last_data_block (handle, 0);                    
  return rtems_rfs_inode_time_stamp_now (handle, true, true);         
   3784c:	eaffff78 	b	37634 <rtems_rfs_inode_time_stamp_now>          <== NOT EXECUTED
                                                                      

0003792c <rtems_rfs_inode_load>: /* * An inode does not move so once loaded no need to do again. */ if (!rtems_rfs_inode_is_loaded (handle))
   3792c:	e591300c 	ldr	r3, [r1, #12]                                 <== NOT EXECUTED
   37930:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_inode_load (rtems_rfs_file_system*  fs,                     
                      rtems_rfs_inode_handle* handle)                 
{                                                                     
   37934:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   37938:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * An inode does not move so once loaded no need to do again.       
   */                                                                 
                                                                      
  if (!rtems_rfs_inode_is_loaded (handle))                            
   3793c:	1a00000b 	bne	37970 <rtems_rfs_inode_load+0x44>             <== NOT EXECUTED
  {                                                                   
    int rc;                                                           
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,         
   37940:	e2811010 	add	r1, r1, #16                                   <== NOT EXECUTED
   37944:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
   37948:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   3794c:	ebfff363 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
                                          handle->block, true);       
    if (rc > 0)                                                       
   37950:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   37954:	c8bd8010 	popgt	{r4, pc}                                    <== NOT EXECUTED
      return rc;                                                      
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
   37958:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
    handle->node += handle->offset;                                   
   3795c:	e5941020 	ldr	r1, [r4, #32]                                 <== NOT EXECUTED
    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,         
                                          handle->block, true);       
    if (rc > 0)                                                       
      return rc;                                                      
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
   37960:	e5932020 	ldr	r2, [r3, #32]                                 <== NOT EXECUTED
    handle->node += handle->offset;                                   
   37964:	e3a00038 	mov	r0, #56	; 0x38                                <== NOT EXECUTED
   37968:	e0232190 	mla	r3, r0, r1, r2                                <== NOT EXECUTED
   3796c:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  handle->loads++;                                                    
   37970:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
   37974:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   37978:	e5843024 	str	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
   3797c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   37980:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00037984 <rtems_rfs_inode_open>: int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN)) printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino); if (ino == RTEMS_RFS_EMPTY_INO)
   37984:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_inode_open (rtems_rfs_file_system*  fs,                     
                      rtems_rfs_ino           ino,                    
                      rtems_rfs_inode_handle* handle,                 
                      bool                    load)                   
{                                                                     
   37988:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   3798c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   37990:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   37994:	e20380ff 	and	r8, r3, #255	; 0xff                           <== NOT EXECUTED
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))                   
    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);        
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
   37998:	0a000027 	beq	37a3c <rtems_rfs_inode_open+0xb8>             <== NOT EXECUTED
    return EINVAL;                                                    
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
   3799c:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   379a0:	e2417001 	sub	r7, r1, #1                                    <== NOT EXECUTED
   379a4:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
   379a8:	8a000023 	bhi	37a3c <rtems_rfs_inode_open+0xb8>             <== NOT EXECUTED
    return EINVAL;                                                    
                                                                      
  handle->ino = ino;                                                  
   379ac:	e5821008 	str	r1, [r2, #8]                                  <== NOT EXECUTED
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
   379b0:	e5909028 	ldr	r9, [r0, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
    return EINVAL;                                                    
                                                                      
  handle->ino = ino;                                                  
  handle->node = NULL;                                                
   379b4:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
   379b8:	e582600c 	str	r6, [r2, #12]                                 <== NOT EXECUTED
  handle->loads = 0;                                                  
   379bc:	e5826024 	str	r6, [r2, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
   379c0:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   379c4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   379c8:	eb00759e 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
   379cc:	e594a02c 	ldr	sl, [r4, #44]	; 0x2c                          <== NOT EXECUTED
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
   379d0:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
  handle->node = NULL;                                                
  handle->loads = 0;                                                  
                                                                      
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
   379d4:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
   379d8:	eb00759a 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
   379dc:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
  gino  = ino - RTEMS_RFS_ROOT_INO;                                   
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
   379e0:	e5850020 	str	r0, [r5, #32]                                 <== NOT EXECUTED
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
   379e4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   379e8:	eb007502 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   379ec:	e3a03050 	mov	r3, #80	; 0x50                                <== NOT EXECUTED
   379f0:	e0000093 	mul	r0, r3, r0                                    <== NOT EXECUTED
   379f4:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   379f8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   379fc:	e7937000 	ldr	r7, [r3, r0]                                  <== NOT EXECUTED
   37a00:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   37a04:	eb0074fb 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   37a08:	e2877002 	add	r7, r7, #2                                    <== NOT EXECUTED
   37a0c:	e0870000 	add	r0, r7, r0                                    <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
   37a10:	e1580006 	cmp	r8, r6                                        <== NOT EXECUTED
  group = gino / fs->group_inodes;                                    
  gino  = gino % fs->group_inodes;                                    
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
   37a14:	e585001c 	str	r0, [r5, #28]                                 <== NOT EXECUTED
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   37a18:	e5856018 	str	r6, [r5, #24]                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   37a1c:	e5c56010 	strb	r6, [r5, #16]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   37a20:	e5856014 	str	r6, [r5, #20]                                 <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
   37a24:	01a00008 	moveq	r0, r8                                      <== NOT EXECUTED
   37a28:	08bd8ff0 	popeq	{r4, r5, r6, r7, r8, r9, sl, fp, pc}        <== NOT EXECUTED
    rc = rtems_rfs_inode_load (fs, handle);                           
   37a2c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37a30:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   37a34:	e8bd4ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, lr}          <== NOT EXECUTED
  handle->offset = gino % fs->inodes_per_block;                       
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
    rc = rtems_rfs_inode_load (fs, handle);                           
   37a38:	eaffffbb 	b	3792c <rtems_rfs_inode_load>                    <== NOT EXECUTED
   37a3c:	e3a00016 	mov	r0, #22                                       <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   37a40:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00036480 <rtems_rfs_inode_overhead>: static int rtems_rfs_inode_overhead (rtems_rfs_file_system* fs) { int blocks; int bits_per_block; blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
   36480:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
   36484:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
/**                                                                   
 * Return the inode overhead given a number of inodes.                
 */                                                                   
static int                                                            
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)                  
{                                                                     
   36488:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   3648c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   36490:	e0100392 	muls	r0, r2, r3                                   <== NOT EXECUTED
static int                                                            
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)                  
{                                                                     
  int blocks;                                                         
  int bits_per_block;                                                 
  blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
   36494:	e5945008 	ldr	r5, [r4, #8]                                  <== NOT EXECUTED
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
   36498:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
   3649c:	0a000003 	beq	364b0 <rtems_rfs_inode_overhead+0x30>         <== NOT EXECUTED
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
   364a0:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
   364a4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   364a8:	eb007a52 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   364ac:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
                                  rtems_rfs_fs_block_size (fs));      
  bits_per_block = rtems_rfs_bits_per_block (fs);                     
  /*                                                                  
   * There could be more bits than blocks, eg 512K disk with 512 blocks.
   */                                                                 
  if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
   364b0:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
 * Return the number of bits that fit in the block size.              
 */                                                                   
static int                                                            
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)                  
{                                                                     
  return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));  
   364b4:	e1a01185 	lsl	r1, r5, #3                                    <== NOT EXECUTED
                                  rtems_rfs_fs_block_size (fs));      
  bits_per_block = rtems_rfs_bits_per_block (fs);                     
  /*                                                                  
   * There could be more bits than blocks, eg 512K disk with 512 blocks.
   */                                                                 
  if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
   364b8:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
   364bc:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
   364c0:	21a01003 	movcs	r1, r3                                      <== NOT EXECUTED
   364c4:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
   364c8:	e3a03ffa 	mov	r3, #1000	; 0x3e8                             <== NOT EXECUTED
   364cc:	e0000093 	mul	r0, r3, r0                                    <== NOT EXECUTED
   364d0:	eb007a8c 	bl	54f08 <__aeabi_idiv>                           <== NOT EXECUTED
  return ((blocks + 1) * 100 * 10) / bits_per_block;                  
}                                                                     
   364d4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00037634 <rtems_rfs_inode_time_stamp_now>: rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle, bool atime, bool mtime) { time_t now; if (!rtems_rfs_inode_is_loaded (handle))
   37634:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
   37638:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,       
                                bool                    atime,        
                                bool                    mtime)        
{                                                                     
   3763c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   37640:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   37644:	e20160ff 	and	r6, r1, #255	; 0xff                           <== NOT EXECUTED
   37648:	e20250ff 	and	r5, r2, #255	; 0xff                           <== NOT EXECUTED
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
   3764c:	03a00006 	moveq	r0, #6                                      <== NOT EXECUTED
   37650:	08bd8070 	popeq	{r4, r5, r6, pc}                            <== NOT EXECUTED
    return ENXIO;                                                     
  now = time (NULL);                                                  
   37654:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   37658:	eb00459a 	bl	48cc8 <time>                                   <== NOT EXECUTED
  if (atime)                                                          
   3765c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   37660:	0a00000c 	beq	37698 <rtems_rfs_inode_time_stamp_now+0x64>   <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          atime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->atime, atime);                  
   37664:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   37668:	e1a02c20 	lsr	r2, r0, #24                                   <== NOT EXECUTED
   3766c:	e5c32010 	strb	r2, [r3, #16]                                <== NOT EXECUTED
   37670:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   37674:	e1a02820 	lsr	r2, r0, #16                                   <== NOT EXECUTED
   37678:	e5c32011 	strb	r2, [r3, #17]                                <== NOT EXECUTED
   3767c:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   37680:	e1a02420 	lsr	r2, r0, #8                                    <== NOT EXECUTED
   37684:	e5c32012 	strb	r2, [r3, #18]                                <== NOT EXECUTED
   37688:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   3768c:	e5c30013 	strb	r0, [r3, #19]                                <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   37690:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   37694:	e5c43010 	strb	r3, [r4, #16]                                <== NOT EXECUTED
    rtems_rfs_inode_set_atime (handle, now);                          
  if (mtime)                                                          
   37698:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   3769c:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
   376a0:	08bd8070 	popeq	{r4, r5, r6, pc}                            <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          mtime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->mtime, mtime);                  
   376a4:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   376a8:	e1a02c20 	lsr	r2, r0, #24                                   <== NOT EXECUTED
   376ac:	e5c32014 	strb	r2, [r3, #20]                                <== NOT EXECUTED
   376b0:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   376b4:	e1a02820 	lsr	r2, r0, #16                                   <== NOT EXECUTED
   376b8:	e5c32015 	strb	r2, [r3, #21]                                <== NOT EXECUTED
   376bc:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   376c0:	e1a02420 	lsr	r2, r0, #8                                    <== NOT EXECUTED
   376c4:	e5c32016 	strb	r2, [r3, #22]                                <== NOT EXECUTED
   376c8:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   376cc:	e5c30017 	strb	r0, [r3, #23]                                <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   376d0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   376d4:	e5c43010 	strb	r3, [r4, #16]                                <== NOT EXECUTED
   376d8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    rtems_rfs_inode_set_mtime (handle, now);                          
  return 0;                                                           
}                                                                     
   376dc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00037850 <rtems_rfs_inode_unload>: if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD)) printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n", handle->ino, handle->loads, rtems_rfs_inode_is_loaded (handle) ? "yes" : "no"); if (rtems_rfs_inode_is_loaded (handle))
   37850:	e591300c 	ldr	r3, [r1, #12]                                 <== NOT EXECUTED
   37854:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_inode_unload (rtems_rfs_file_system*  fs,                   
                        rtems_rfs_inode_handle* handle,               
                        bool                    update_ctime)         
{                                                                     
   37858:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   3785c:	e20220ff 	and	r2, r2, #255	; 0xff                           <== NOT EXECUTED
   37860:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
   37864:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))                 
    printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
            handle->ino, handle->loads,                               
            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");       
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
   37868:	0a000020 	beq	378f0 <rtems_rfs_inode_unload+0xa0>           <== NOT EXECUTED
  {                                                                   
    if (handle->loads == 0)                                           
   3786c:	e5910024 	ldr	r0, [r1, #36]	; 0x24                          <== NOT EXECUTED
   37870:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   37874:	02800005 	addeq	r0, r0, #5                                  <== NOT EXECUTED
   37878:	08bd8030 	popeq	{r4, r5, pc}                                <== NOT EXECUTED
      return EIO;                                                     
                                                                      
    handle->loads--;                                                  
   3787c:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
                                                                      
    if (handle->loads == 0)                                           
   37880:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  if (rtems_rfs_inode_is_loaded (handle))                             
  {                                                                   
    if (handle->loads == 0)                                           
      return EIO;                                                     
                                                                      
    handle->loads--;                                                  
   37884:	e5810024 	str	r0, [r1, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
    if (handle->loads == 0)                                           
   37888:	1a000018 	bne	378f0 <rtems_rfs_inode_unload+0xa0>           <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * If the buffer is dirty it will be release. Also set the ctime.
       */                                                             
      if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)   
   3788c:	e5d13010 	ldrb	r3, [r1, #16]                                <== NOT EXECUTED
   37890:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   37894:	0a00000f 	beq	378d8 <rtems_rfs_inode_unload+0x88>           <== NOT EXECUTED
   37898:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   3789c:	0a00000d 	beq	378d8 <rtems_rfs_inode_unload+0x88>           <== NOT EXECUTED
        rtems_rfs_inode_set_ctime (handle, time (NULL));              
   378a0:	eb004508 	bl	48cc8 <time>                                   <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          ctime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->ctime, ctime);                  
   378a4:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   378a8:	e1a02c20 	lsr	r2, r0, #24                                   <== NOT EXECUTED
   378ac:	e5c32018 	strb	r2, [r3, #24]                                <== NOT EXECUTED
   378b0:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   378b4:	e1a02820 	lsr	r2, r0, #16                                   <== NOT EXECUTED
   378b8:	e5c32019 	strb	r2, [r3, #25]                                <== NOT EXECUTED
   378bc:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   378c0:	e1a02420 	lsr	r2, r0, #8                                    <== NOT EXECUTED
   378c4:	e5c3201a 	strb	r2, [r3, #26]                                <== NOT EXECUTED
   378c8:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   378cc:	e5c3001b 	strb	r0, [r3, #27]                                <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   378d0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   378d4:	e5c43010 	strb	r3, [r4, #16]                                <== NOT EXECUTED
      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);     
   378d8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   378dc:	e2841010 	add	r1, r4, #16                                   <== NOT EXECUTED
   378e0:	ebfff335 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
      handle->node = NULL;                                            
   378e4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   378e8:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
   378ec:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
   378f0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
   378f4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00038314 <rtems_rfs_link>: const char* name, int length, rtems_rfs_ino parent, rtems_rfs_ino target, bool link_dir) {
   38314:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   38318:	e24dd054 	sub	sp, sp, #84	; 0x54                            <== NOT EXECUTED
   3831c:	e59db078 	ldr	fp, [sp, #120]	; 0x78                         <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
   38320:	e28d5004 	add	r5, sp, #4                                    <== NOT EXECUTED
                const char*            name,                          
                int                    length,                        
                rtems_rfs_ino          parent,                        
                rtems_rfs_ino          target,                        
                bool                   link_dir)                      
{                                                                     
   38324:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
   38328:	e1a0a002 	mov	sl, r2                                        <== NOT EXECUTED
   3832c:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
   38330:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   38334:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   38338:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
                const char*            name,                          
                int                    length,                        
                rtems_rfs_ino          parent,                        
                rtems_rfs_ino          target,                        
                bool                   link_dir)                      
{                                                                     
   3833c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   38340:	e5dd707c 	ldrb	r7, [sp, #124]	; 0x7c                        <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
   38344:	ebfffd8e 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   38348:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   3834c:	1a000043 	bne	38460 <rtems_rfs_link+0x14c>                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the target inode is a directory and we cannot link directories
   * return a not supported error code.                               
   */                                                                 
  if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
   38350:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
   38354:	1a00000a 	bne	38384 <rtems_rfs_link+0x70>                   <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   38358:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   3835c:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   38360:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   38364:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   38368:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   3836c:	1a000004 	bne	38384 <rtems_rfs_link+0x70>                   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
   38370:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38374:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   38378:	ebfffd5e 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   3837c:	e3a09086 	mov	r9, #134	; 0x86                               <== NOT EXECUTED
    return ENOTSUP;                                                   
   38380:	ea000036 	b	38460 <rtems_rfs_link+0x14c>                    <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
   38384:	e28d502c 	add	r5, sp, #44	; 0x2c                            <== NOT EXECUTED
   38388:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3838c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38390:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   38394:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38398:	ebfffd79 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   3839c:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   383a0:	1a00000a 	bne	383d0 <rtems_rfs_link+0xbc>                   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
   383a4:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   383a8:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   383ac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   383b0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   383b4:	e58db000 	str	fp, [sp]                                      <== NOT EXECUTED
   383b8:	ebfff2f9 	bl	34fa4 <rtems_rfs_dir_add_entry>                <== NOT EXECUTED
  if (rc > 0)                                                         
   383bc:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   383c0:	da000006 	ble	383e0 <rtems_rfs_link+0xcc>                   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
   383c4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   383c8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   383cc:	ebfffd49 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
   383d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   383d4:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
   383d8:	ebfffd46 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    return rc;                                                        
   383dc:	ea00001f 	b	38460 <rtems_rfs_link+0x14c>                    <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   383e0:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   383e4:	e5d31000 	ldrb	r1, [r3]                                     <== NOT EXECUTED
   383e8:	e5d32001 	ldrb	r2, [r3, #1]                                 <== NOT EXECUTED
   383ec:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
  if (links == 0xffff)                                                
   383f0:	e59f1074 	ldr	r1, [pc, #116]	; 3846c <rtems_rfs_link+0x158> <== NOT EXECUTED
   383f4:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   383f8:	03a02000 	moveq	r2, #0                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode) + 1;              
   383fc:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
   38400:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
 * @prarm links The links.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
   38404:	e1a01c22 	lsr	r1, r2, #24                                   <== NOT EXECUTED
   38408:	e5c31000 	strb	r1, [r3]                                     <== NOT EXECUTED
   3840c:	e59d0010 	ldr	r0, [sp, #16]                                 <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   38410:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38414:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
 * @prarm links The links.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
   38418:	e5c02001 	strb	r2, [r0, #1]                                 <== NOT EXECUTED
  rtems_rfs_inode_set_links (&target_inode, links);                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
   3841c:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
   38420:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38424:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   38428:	e5cd3014 	strb	r3, [sp, #20]                                <== NOT EXECUTED
   3842c:	ebfffc80 	bl	37634 <rtems_rfs_inode_time_stamp_now>         <== NOT EXECUTED
  if (rc > 0)                                                         
   38430:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   38434:	caffffe2 	bgt	383c4 <rtems_rfs_link+0xb0>                   <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &parent_inode);                        
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
   38438:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   3843c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38440:	ebfffd2c 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   38444:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   38448:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
   3844c:	c1a00004 	movgt	r0, r4                                      <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
  if (rc > 0)                                                         
   38450:	caffffe0 	bgt	383d8 <rtems_rfs_link+0xc4>                   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
   38454:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38458:	ebfffd26 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   3845c:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
   38460:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   38464:	e28dd054 	add	sp, sp, #84	; 0x54                            <== NOT EXECUTED
   38468:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0003848c <rtems_rfs_mutex_create>: RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL) #endif int rtems_rfs_mutex_create (rtems_rfs_mutex* mutex) {
   3848c:	e92d4001 	push	{r0, lr}                                     <== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc;                                               
  sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'), 
   38490:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   38494:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   38498:	e3a02024 	mov	r2, #36	; 0x24                                <== NOT EXECUTED
   3849c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   384a0:	e59f0010 	ldr	r0, [pc, #16]	; 384b8 <rtems_rfs_mutex_create+0x2c><== NOT EXECUTED
   384a4:	ebff4c5c 	bl	b61c <rtems_semaphore_create>                  <== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
   384a8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   384ac:	13a00005 	movne	r0, #5                                      <== NOT EXECUTED
   384b0:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   384b4:	e8bd8008 	pop	{r3, pc}                                      <== NOT EXECUTED
                                                                      

00038470 <rtems_rfs_mutex_destroy>: return 0; } int rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex) {
   38470:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
#if __rtems__                                                         
  rtems_status_code sc;                                               
  sc = rtems_semaphore_delete (*mutex);                               
   38474:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   38478:	ebff4cd2 	bl	b7c8 <rtems_semaphore_delete>                  <== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
   3847c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   38480:	13a00005 	movne	r0, #5                                      <== NOT EXECUTED
   38484:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   38488:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00034408 <rtems_rfs_release_chain>: static int rtems_rfs_release_chain (rtems_chain_control* chain, uint32_t* count, bool modified) {
   34408:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
   3440c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   34410:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   34414:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   34418:	e202a0ff 	and	sl, r2, #255	; 0xff                           <== NOT EXECUTED
   3441c:	e2808004 	add	r8, r0, #4                                    <== NOT EXECUTED
  while (!rtems_chain_is_empty (chain))                               
  {                                                                   
    buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);             
    (*count)--;                                                       
                                                                      
    buffer->user = (void*) 0;                                         
   34420:	e1a07005 	mov	r7, r5                                        <== NOT EXECUTED
  int               rc;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count); 
                                                                      
  while (!rtems_chain_is_empty (chain))                               
   34424:	ea00000d 	b	34460 <rtems_rfs_release_chain+0x58>            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
   34428:	ebff600d 	bl	c464 <_Chain_Get>                              <== NOT EXECUTED
  {                                                                   
    buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);             
    (*count)--;                                                       
   3442c:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
   34430:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   34434:	e5862000 	str	r2, [r6]                                      <== NOT EXECUTED
                                                                      
    buffer->user = (void*) 0;                                         
   34438:	e5807038 	str	r7, [r0, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
   3443c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   34440:	eb002145 	bl	3c95c <rtems_rfs_buffer_bdbuf_release>         <== NOT EXECUTED
    if ((rc > 0) && (rrc == 0))                                       
   34444:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   34448:	d3a03000 	movle	r3, #0                                      <== NOT EXECUTED
   3444c:	c3a03001 	movgt	r3, #1                                      <== NOT EXECUTED
   34450:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   34454:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
   34458:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   3445c:	11a05000 	movne	r5, r0                                      <== NOT EXECUTED
  int               rc;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count); 
                                                                      
  while (!rtems_chain_is_empty (chain))                               
   34460:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
   34464:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
   34468:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3446c:	1affffed 	bne	34428 <rtems_rfs_release_chain+0x20>          <== NOT EXECUTED
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
      rrc = rc;                                                       
  }                                                                   
  return rrc;                                                         
}                                                                     
   34470:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   34474:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

0001e10c <rtems_rfs_rtems_chown>: static int rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc, uid_t owner, gid_t group) {
   1e10c:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1e110:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1e114:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1e118:	e5908000 	ldr	r8, [r0]                                      <== NOT EXECUTED
                                                                      
static int                                                            
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,     
                       uid_t                             owner,       
                       gid_t                             group)       
{                                                                     
   1e11c:	e24dd028 	sub	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   1e120:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
   1e124:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))            
    printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
            ino, owner, group);                                       
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e128:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
static int                                                            
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,     
                       uid_t                             owner,       
                       gid_t                             group)       
{                                                                     
   1e12c:	e1a06821 	lsr	r6, r1, #16                                   <== NOT EXECUTED
   1e130:	e1a07822 	lsr	r7, r2, #16                                   <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))            
    printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
            ino, owner, group);                                       
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e134:	ebffffe9 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e138:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1e13c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e140:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   1e144:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e148:	eb00660d 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   1e14c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
    printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
            ino, owner, group);                                       
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e150:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
  if (rc > 0)                                                         
   1e154:	da000004 	ble	1e16c <rtems_rfs_rtems_chown+0x60>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e158:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e15c:	ebffffe4 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("chown: opening inode", rc);        
   1e160:	eb007b66 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e164:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   1e168:	ea000016 	b	1e1c8 <rtems_rfs_rtems_chown+0xbc>              <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,          
                             uint16_t uid, uint16_t gid)              
{                                                                     
  rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
   1e16c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e170:	e1867807 	orr	r7, r6, r7, lsl #16                           <== NOT EXECUTED
   1e174:	e1a02c27 	lsr	r2, r7, #24                                   <== NOT EXECUTED
   1e178:	e5c32004 	strb	r2, [r3, #4]                                 <== NOT EXECUTED
   1e17c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e180:	e1a02827 	lsr	r2, r7, #16                                   <== NOT EXECUTED
   1e184:	e5c32005 	strb	r2, [r3, #5]                                 <== NOT EXECUTED
   1e188:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e18c:	e1a07427 	lsr	r7, r7, #8                                    <== NOT EXECUTED
   1e190:	e5c37006 	strb	r7, [r3, #6]                                 <== NOT EXECUTED
   1e194:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
  }                                                                   
#endif                                                                
                                                                      
  rtems_rfs_inode_set_uid_gid (&inode, owner, group);                 
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1e198:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   1e19c:	e5c36007 	strb	r6, [r3, #7]                                 <== NOT EXECUTED
   1e1a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   1e1a4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e1a8:	e5cd3010 	strb	r3, [sp, #16]                                <== NOT EXECUTED
   1e1ac:	eb0065d1 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc)                                                             
   1e1b0:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e1b4:	0a000005 	beq	1e1d0 <rtems_rfs_rtems_chown+0xc4>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e1b8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e1bc:	ebffffcc 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("chown: closing inode", rc);        
   1e1c0:	eb007b4e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e1c4:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e1c8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e1cc:	ea000002 	b	1e1dc <rtems_rfs_rtems_chown+0xd0>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e1d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e1d4:	ebffffc6 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e1d8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e1dc:	e28dd028 	add	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   1e1e0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

000385c0 <rtems_rfs_rtems_device_close>: * @return int */ static int rtems_rfs_rtems_device_close (rtems_libio_t* iop) {
   385c0:	e92d4007 	push	{r0, r1, r2, lr}                             <== NOT EXECUTED
   385c4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop   = iop;                                                   
  args.flags = 0;                                                     
   385c8:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
  rtems_libio_open_close_args_t args;                                 
  rtems_status_code             status;                               
  int                           major;                                
  int                           minor;                                
                                                                      
  major = (int) iop->data0;                                           
   385cc:	e5900030 	ldr	r0, [r0, #48]	; 0x30                          <== NOT EXECUTED
  minor = (intptr_t) iop->data1;                                      
   385d0:	e5931034 	ldr	r1, [r3, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  args.iop   = iop;                                                   
  args.flags = 0;                                                     
  args.mode  = 0;                                                     
                                                                      
  status = rtems_io_close (major, minor, (void *) &args);             
   385d4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  int                           minor;                                
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop   = iop;                                                   
   385d8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.flags = 0;                                                     
  args.mode  = 0;                                                     
   385dc:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop   = iop;                                                   
  args.flags = 0;                                                     
   385e0:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
  args.mode  = 0;                                                     
                                                                      
  status = rtems_io_close (major, minor, (void *) &args);             
   385e4:	eb0007cf 	bl	3a528 <rtems_io_close>                         <== NOT EXECUTED
  if (status)                                                         
   385e8:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   385ec:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
    return rtems_deviceio_errno (status);                             
   385f0:	1b000251 	blne	38f3c <rtems_deviceio_errno>                 <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   385f4:	e8bd800e 	pop	{r1, r2, r3, pc}                              <== NOT EXECUTED
                                                                      

000384c8 <rtems_rfs_rtems_device_ftruncate>: static int rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length) { return 0; }
   384c8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   384cc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

000384d0 <rtems_rfs_rtems_device_ioctl>: static int rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer) {
   384d0:	e92d400f 	push	{r0, r1, r2, r3, lr}                         <== NOT EXECUTED
   384d4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_status_code        status;                                    
  int                      major;                                     
  int                      minor;                                     
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
   384d8:	e593c034 	ldr	ip, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_libio_ioctl_args_t args;                                      
  rtems_status_code        status;                                    
  int                      major;                                     
  int                      minor;                                     
                                                                      
  major = (int) iop->data0;                                           
   384dc:	e5900030 	ldr	r0, [r0, #48]	; 0x30                          <== NOT EXECUTED
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop     = iop;                                                 
  args.command = command;                                             
  args.buffer  = buffer;                                              
   384e0:	e98d0006 	stmib	sp, {r1, r2}                                <== NOT EXECUTED
                                                                      
  status = rtems_io_control (major, minor, (void *) &args);           
   384e4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   384e8:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
  int                      minor;                                     
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop     = iop;                                                 
   384ec:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.command = command;                                             
  args.buffer  = buffer;                                              
                                                                      
  status = rtems_io_control (major, minor, (void *) &args);           
   384f0:	eb000820 	bl	3a578 <rtems_io_control>                       <== NOT EXECUTED
  if (status)                                                         
   384f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno (status);                             
                                                                      
  return args.ioctl_return;                                           
   384f8:	059d000c 	ldreq	r0, [sp, #12]                               <== NOT EXECUTED
  args.command = command;                                             
  args.buffer  = buffer;                                              
                                                                      
  status = rtems_io_control (major, minor, (void *) &args);           
  if (status)                                                         
    return rtems_deviceio_errno (status);                             
   384fc:	1b00028e 	blne	38f3c <rtems_deviceio_errno>                 <== NOT EXECUTED
                                                                      
  return args.ioctl_return;                                           
}                                                                     
   38500:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   38504:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

000384bc <rtems_rfs_rtems_device_lseek>: rtems_rfs_rtems_device_lseek (rtems_libio_t* iop, rtems_off64_t offset, int whence) { return offset; }
   384bc:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   384c0:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
   384c4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00038610 <rtems_rfs_rtems_device_open>: static int rtems_rfs_rtems_device_open ( rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode) {
   38610:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_libio_open_close_args_t args;                                 
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   38614:	e5902028 	ldr	r2, [r0, #40]	; 0x28                          <== NOT EXECUTED
   38618:	e5925034 	ldr	r5, [r2, #52]	; 0x34                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
   3861c:	e595207c 	ldr	r2, [r5, #124]	; 0x7c                         <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,                     
                              const char    *pathname,                
                              uint32_t       flag,                    
                              uint32_t       mode)                    
{                                                                     
   38620:	e24dd040 	sub	sp, sp, #64	; 0x40                            <== NOT EXECUTED
  rtems_libio_open_close_args_t args;                                 
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_iop_ino (iop);
   38624:	e5907038 	ldr	r7, [r0, #56]	; 0x38                          <== NOT EXECUTED
   38628:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,                     
                              const char    *pathname,                
                              uint32_t       flag,                    
                              uint32_t       mode)                    
{                                                                     
   3862c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_status_code             status;                               
  int                           rc;                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   38630:	e28d600c 	add	r6, sp, #12                                   <== NOT EXECUTED
   38634:	e5920000 	ldr	r0, [r2]                                      <== NOT EXECUTED
   38638:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,                     
                              const char    *pathname,                
                              uint32_t       flag,                    
                              uint32_t       mode)                    
{                                                                     
   3863c:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   38640:	ebff4c9e 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  rtems_status_code             status;                               
  int                           rc;                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   38644:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   38648:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3864c:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   38650:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38654:	ebfffcca 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   38658:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   3865c:	da000004 	ble	38674 <rtems_rfs_rtems_device_open+0x64>      <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   38660:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38664:	ebffffe3 	bl	385f8 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: opening inode", rc);  
   38668:	eb001224 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3866c:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   38670:	ea000016 	b	386d0 <rtems_rfs_rtems_device_open+0xc0>        <== NOT EXECUTED
 * @return uint32_t The block number.                                 
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block) 
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);      
   38674:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
   38678:	e283201c 	add	r2, r3, #28                                   <== NOT EXECUTED
   3867c:	e5d2c006 	ldrb	ip, [r2, #6]                                 <== NOT EXECUTED
   38680:	e5d3a01c 	ldrb	sl, [r3, #28]                                <== NOT EXECUTED
   38684:	e5d23002 	ldrb	r3, [r2, #2]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  major = rtems_rfs_inode_get_block (&inode, 0);                      
  minor = rtems_rfs_inode_get_block (&inode, 1);                      
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   38688:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   3868c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38690:	e5d26007 	ldrb	r6, [r2, #7]                                 <== NOT EXECUTED
   38694:	e5d27001 	ldrb	r7, [r2, #1]                                 <== NOT EXECUTED
   38698:	e5d28003 	ldrb	r8, [r2, #3]                                 <== NOT EXECUTED
   3869c:	e5d29004 	ldrb	r9, [r2, #4]                                 <== NOT EXECUTED
   386a0:	e5d2b005 	ldrb	fp, [r2, #5]                                 <== NOT EXECUTED
   386a4:	e88d1008 	stm	sp, {r3, ip}                                  <== NOT EXECUTED
   386a8:	ebfffc92 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   386ac:	e2502000 	subs	r2, r0, #0                                   <== NOT EXECUTED
   386b0:	e89d1008 	ldm	sp, {r3, ip}                                  <== NOT EXECUTED
   386b4:	da000007 	ble	386d8 <rtems_rfs_rtems_device_open+0xc8>      <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   386b8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   386bc:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
   386c0:	ebffffcc 	bl	385f8 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
   386c4:	eb00120d 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   386c8:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
   386cc:	e5802000 	str	r2, [r0]                                      <== NOT EXECUTED
   386d0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   386d4:	ea000016 	b	38734 <rtems_rfs_rtems_device_open+0x124>       <== NOT EXECUTED
   386d8:	e1a0b80b 	lsl	fp, fp, #16                                   <== NOT EXECUTED
   386dc:	e18b9c09 	orr	r9, fp, r9, lsl #24                           <== NOT EXECUTED
   386e0:	e1888c0a 	orr	r8, r8, sl, lsl #24                           <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   386e4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   386e8:	e1887807 	orr	r7, r8, r7, lsl #16                           <== NOT EXECUTED
   386ec:	e1896006 	orr	r6, r9, r6                                    <== NOT EXECUTED
   386f0:	e1877403 	orr	r7, r7, r3, lsl #8                            <== NOT EXECUTED
   386f4:	e186640c 	orr	r6, r6, ip, lsl #8                            <== NOT EXECUTED
   386f8:	ebffffbe 	bl	385f8 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  iop->data0 = major;                                                 
  iop->data1 = (void*)((intptr_t) minor);                             
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
   386fc:	e594e014 	ldr	lr, [r4, #20]                                 <== NOT EXECUTED
  args.mode  = mode;                                                  
   38700:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  iop->data0 = major;                                                 
   38704:	e5847030 	str	r7, [r4, #48]	; 0x30                          <== NOT EXECUTED
  iop->data1 = (void*)((intptr_t) minor);                             
   38708:	e5846034 	str	r6, [r4, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
                                                                      
  status = rtems_io_open (major, minor, (void *) &args);              
   3870c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   38710:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   38714:	e28d2034 	add	r2, sp, #52	; 0x34                            <== NOT EXECUTED
  iop->data0 = major;                                                 
  iop->data1 = (void*)((intptr_t) minor);                             
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
   38718:	e58d303c 	str	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
  iop->data0 = major;                                                 
  iop->data1 = (void*)((intptr_t) minor);                             
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
   3871c:	e58de038 	str	lr, [sp, #56]	; 0x38                          <== NOT EXECUTED
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  iop->data0 = major;                                                 
  iop->data1 = (void*)((intptr_t) minor);                             
                                                                      
  args.iop   = iop;                                                   
   38720:	e58d4034 	str	r4, [sp, #52]	; 0x34                          <== NOT EXECUTED
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
                                                                      
  status = rtems_io_open (major, minor, (void *) &args);              
   38724:	eb0007a7 	bl	3a5c8 <rtems_io_open>                          <== NOT EXECUTED
  if (status)                                                         
   38728:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
   3872c:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
   38730:	1b000201 	blne	38f3c <rtems_deviceio_errno>                 <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   38734:	e28dd040 	add	sp, sp, #64	; 0x40                            <== NOT EXECUTED
   38738:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00038564 <rtems_rfs_rtems_device_read>: * @return ssize_t */ static ssize_t rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count) {
   38564:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   38568:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
   3856c:	e593c014 	ldr	ip, [r3, #20]                                 <== NOT EXECUTED
  rtems_status_code     status;                                       
  int                   major;                                        
  int                   minor;                                        
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
   38570:	e593e034 	ldr	lr, [r3, #52]	; 0x34                          <== NOT EXECUTED
 * @return ssize_t                                                    
 */                                                                   
                                                                      
static ssize_t                                                        
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{                                                                     
   38574:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
   38578:	e283500c 	add	r5, r3, #12                                   <== NOT EXECUTED
   3857c:	e8950030 	ldm	r5, {r4, r5}                                  <== NOT EXECUTED
  rtems_libio_rw_args_t args;                                         
  rtems_status_code     status;                                       
  int                   major;                                        
  int                   minor;                                        
                                                                      
  major = (int) iop->data0;                                           
   38580:	e5900030 	ldr	r0, [r0, #48]	; 0x30                          <== NOT EXECUTED
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
   38584:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
   38588:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  args.flags       = iop->flags;                                      
   3858c:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read (major, minor, (void *) &args);              
   38590:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
   38594:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
                                                                      
  status = rtems_io_read (major, minor, (void *) &args);              
   38598:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
   3859c:	e98d0030 	stmib	sp, {r4, r5}                                <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
   385a0:	e58dc018 	str	ip, [sp, #24]                                 <== NOT EXECUTED
  int                   minor;                                        
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
   385a4:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read (major, minor, (void *) &args);              
   385a8:	eb00081a 	bl	3a618 <rtems_io_read>                          <== NOT EXECUTED
  if (status)                                                         
   385ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno (status);                             
                                                                      
  return (ssize_t) args.bytes_moved;                                  
   385b0:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read (major, minor, (void *) &args);              
  if (status)                                                         
    return rtems_deviceio_errno (status);                             
   385b4:	1b000260 	blne	38f3c <rtems_deviceio_errno>                 <== NOT EXECUTED
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
   385b8:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
   385bc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00038508 <rtems_rfs_rtems_device_write>: static ssize_t rtems_rfs_rtems_device_write (rtems_libio_t* iop, const void* buffer, size_t count) {
   38508:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   3850c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
   38510:	e593c014 	ldr	ip, [r3, #20]                                 <== NOT EXECUTED
  rtems_status_code     status;                                       
  int                   major;                                        
  int                   minor;                                        
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
   38514:	e593e034 	ldr	lr, [r3, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
static ssize_t                                                        
rtems_rfs_rtems_device_write (rtems_libio_t* iop,                     
                              const void*    buffer,                  
                              size_t         count)                   
{                                                                     
   38518:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
   3851c:	e283500c 	add	r5, r3, #12                                   <== NOT EXECUTED
   38520:	e8950030 	ldm	r5, {r4, r5}                                  <== NOT EXECUTED
  rtems_libio_rw_args_t args;                                         
  rtems_status_code     status;                                       
  int                   major;                                        
  int                   minor;                                        
                                                                      
  major = (int) iop->data0;                                           
   38524:	e5900030 	ldr	r0, [r0, #48]	; 0x30                          <== NOT EXECUTED
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
   38528:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
   3852c:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  args.flags       = iop->flags;                                      
   38530:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_write (major, minor, (void *) &args);             
   38534:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
   38538:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
                                                                      
  status = rtems_io_write (major, minor, (void *) &args);             
   3853c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
   38540:	e98d0030 	stmib	sp, {r4, r5}                                <== NOT EXECUTED
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
   38544:	e58dc018 	str	ip, [sp, #24]                                 <== NOT EXECUTED
  int                   minor;                                        
                                                                      
  major = (int) iop->data0;                                           
  minor = (intptr_t) iop->data1;                                      
                                                                      
  args.iop         = iop;                                             
   38548:	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 (major, minor, (void *) &args);             
   3854c:	eb000845 	bl	3a668 <rtems_io_write>                         <== NOT EXECUTED
  if (status)                                                         
   38550:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno (status);                             
                                                                      
  return (ssize_t) args.bytes_moved;                                  
   38554:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_write (major, minor, (void *) &args);             
  if (status)                                                         
    return rtems_deviceio_errno (status);                             
   38558:	1b000277 	blne	38f3c <rtems_deviceio_errno>                 <== NOT EXECUTED
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
   3855c:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
   38560:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

0003873c <rtems_rfs_rtems_dir_close>: { /* * The RFS does not hold any resources. Nothing to do. */ return 0; }
   3873c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   38740:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00038744 <rtems_rfs_rtems_dir_lseek>: static rtems_off64_t rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop, rtems_off64_t offset, int whence) { switch (whence)
   38744:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
 */                                                                   
static rtems_off64_t                                                  
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,                        
                           rtems_off64_t  offset,                     
                           int            whence)                     
{                                                                     
   38748:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  switch (whence)                                                     
   3874c:	93a03000 	movls	r3, #0                                      <== NOT EXECUTED
   38750:	93a04000 	movls	r4, #0                                      <== NOT EXECUTED
   38754:	9a000004 	bls	3876c <rtems_rfs_rtems_dir_lseek+0x28>        <== NOT EXECUTED
      break;                                                          
                                                                      
     case SEEK_END:   /* Movement past the end of the directory via lseek */
                      /* is not a permitted operation                     */
    default:                                                          
      return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL); 
   38758:	eb0011e8 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3875c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   38760:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   38764:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   38768:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
      break;                                                          
  }                                                                   
  return 0;                                                           
}                                                                     
   3876c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   38770:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   38774:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00038934 <rtems_rfs_rtems_dir_open>: rtems_rfs_rtems_dir_open (rtems_libio_t* iop, const char* pathname, uint32_t flag, uint32_t mode) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   38934:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,                         
                          const char*    pathname,                    
                          uint32_t       flag,                        
                          uint32_t       mode)                        
{                                                                     
   38938:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   3893c:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
   38940:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
   38944:	e5907038 	ldr	r7, [r0, #56]	; 0x38                          <== NOT EXECUTED
   38948:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,                         
                          const char*    pathname,                    
                          uint32_t       flag,                        
                          uint32_t       mode)                        
{                                                                     
   3894c:	e24dd028 	sub	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   38950:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   38954:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   38958:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   3895c:	ebff4bd7 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   38960:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   38964:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38968:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   3896c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38970:	ebfffc03 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   38974:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   38978:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
  if (rc)                                                             
   3897c:	0a000004 	beq	38994 <rtems_rfs_rtems_dir_open+0x60>         <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   38980:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38984:	ebffff7b 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_open: opening inode", rc);     
   38988:	eb00115c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   3898c:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   38990:	ea00000d 	b	389cc <rtems_rfs_rtems_dir_open+0x98>           <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   38994:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))         
   38998:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   3899c:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   389a0:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   389a4:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   389a8:	0a000009 	beq	389d4 <rtems_rfs_rtems_dir_open+0xa0>         <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   389ac:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   389b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   389b4:	ebfffbcf 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
   389b8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   389bc:	ebffff6d 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);      
   389c0:	eb00114e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   389c4:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   389c8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   389cc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   389d0:	ea000009 	b	389fc <rtems_rfs_rtems_dir_open+0xc8>           <== NOT EXECUTED
  }                                                                   
                                                                      
  iop->offset = 0;                                                    
   389d4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   389d8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   389dc:	e586200c 	str	r2, [r6, #12]                                 <== NOT EXECUTED
   389e0:	e5863010 	str	r3, [r6, #16]                                 <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   389e4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   389e8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   389ec:	ebfffbc1 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  rtems_rfs_rtems_unlock (fs);                                        
   389f0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   389f4:	ebffff5f 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   389f8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   389fc:	e28dd028 	add	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   38a00:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00038820 <rtems_rfs_rtems_dir_read>: */ static ssize_t rtems_rfs_rtems_dir_read (rtems_libio_t* iop, void* buffer, size_t count) {
   38820:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   38824:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 */                                                                   
static ssize_t                                                        
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,                         
                          void*          buffer,                      
                          size_t         count)                       
{                                                                     
   38828:	e24dd038 	sub	sp, sp, #56	; 0x38                            <== NOT EXECUTED
   3882c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   38830:	e1a09001 	mov	r9, r1                                        <== NOT EXECUTED
  struct dirent*         dirent;                                      
  ssize_t                bytes_transferred;                           
  int                    d;                                           
  int                    rc;                                          
                                                                      
  count  = count / sizeof (struct dirent);                            
   38834:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
   38838:	e3a01e11 	mov	r1, #272	; 0x110                              <== NOT EXECUTED
static ssize_t                                                        
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,                         
                          void*          buffer,                      
                          size_t         count)                       
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   3883c:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
  struct dirent*         dirent;                                      
  ssize_t                bytes_transferred;                           
  int                    d;                                           
  int                    rc;                                          
                                                                      
  count  = count / sizeof (struct dirent);                            
   38840:	eb00716c 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   38844:	e595307c 	ldr	r3, [r5, #124]	; 0x7c                         <== NOT EXECUTED
   38848:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,                         
                          void*          buffer,                      
                          size_t         count)                       
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
   3884c:	e5964038 	ldr	r4, [r6, #56]	; 0x38                          <== NOT EXECUTED
   38850:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  struct dirent*         dirent;                                      
  ssize_t                bytes_transferred;                           
  int                    d;                                           
  int                    rc;                                          
                                                                      
  count  = count / sizeof (struct dirent);                            
   38854:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
  dirent = buffer;                                                    
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   38858:	e28d800c 	add	r8, sp, #12                                   <== NOT EXECUTED
   3885c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38860:	ebff4c16 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
   38864:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   38868:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3886c:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   38870:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38874:	ebfffc42 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   38878:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   3887c:	01a07004 	moveq	r7, r4                                      <== NOT EXECUTED
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
  {                                                                   
    size_t size;                                                      
    rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size); 
   38880:	028da034 	addeq	sl, sp, #52	; 0x34                          <== NOT EXECUTED
  dirent = buffer;                                                    
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
  if (rc)                                                             
   38884:	0a00001d 	beq	38900 <rtems_rfs_rtems_dir_read+0xe0>         <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   38888:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   3888c:	ebffffb9 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
   38890:	eb00119a 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38894:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
   38898:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   3889c:	ea000021 	b	38928 <rtems_rfs_rtems_dir_read+0x108>          <== NOT EXECUTED
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
  {                                                                   
    size_t size;                                                      
    rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size); 
   388a0:	e286300c 	add	r3, r6, #12                                   <== NOT EXECUTED
   388a4:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
   388a8:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   388ac:	e58da004 	str	sl, [sp, #4]                                  <== NOT EXECUTED
   388b0:	ebfff076 	bl	34a90 <rtems_rfs_dir_read>                     <== NOT EXECUTED
    if (rc == ENOENT)                                                 
   388b4:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
   388b8:	0a000015 	beq	38914 <rtems_rfs_rtems_dir_read+0xf4>         <== NOT EXECUTED
    {                                                                 
      rc = 0;                                                         
      break;                                                          
    }                                                                 
    if (rc > 0)                                                       
   388bc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   388c0:	da000005 	ble	388dc <rtems_rfs_rtems_dir_read+0xbc>         <== NOT EXECUTED
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
   388c4:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
   388c8:	eb00118c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   388cc:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   388d0:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   388d4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   388d8:	ea00000d 	b	38914 <rtems_rfs_rtems_dir_read+0xf4>           <== NOT EXECUTED
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
   388dc:	e286100c 	add	r1, r6, #12                                   <== NOT EXECUTED
   388e0:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
   388e4:	e59dc034 	ldr	ip, [sp, #52]	; 0x34                          <== NOT EXECUTED
   388e8:	e090200c 	adds	r2, r0, ip                                   <== NOT EXECUTED
   388ec:	e2a13000 	adc	r3, r1, #0                                    <== NOT EXECUTED
   388f0:	e586200c 	str	r2, [r6, #12]                                 <== NOT EXECUTED
   388f4:	e5863010 	str	r3, [r6, #16]                                 <== NOT EXECUTED
   388f8:	e2844e11 	add	r4, r4, #272	; 0x110                          <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
   388fc:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
   38900:	e157000b 	cmp	r7, fp                                        <== NOT EXECUTED
  {                                                                   
    size_t size;                                                      
    rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size); 
   38904:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38908:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
 * 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.                                                             
 */                                                                   
static ssize_t                                                        
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,                         
   3890c:	e089c004 	add	ip, r9, r4                                    <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
   38910:	3affffe2 	bcc	388a0 <rtems_rfs_rtems_dir_read+0x80>         <== NOT EXECUTED
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   38914:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38918:	e28d100c 	add	r1, sp, #12                                   <== NOT EXECUTED
   3891c:	ebfffbf5 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  rtems_rfs_rtems_unlock (fs);                                        
   38920:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38924:	ebffff93 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return bytes_transferred;                                           
}                                                                     
   38928:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3892c:	e28dd038 	add	sp, sp, #56	; 0x38                            <== NOT EXECUTED
   38930:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00038790 <rtems_rfs_rtems_dir_rmnod>: static int rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc, rtems_filesystem_location_info_t* pathloc) {
   38790:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   38794:	e5915000 	ldr	r5, [r1]                                      <== NOT EXECUTED
                                                                      
static int                                                            
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
                           rtems_filesystem_location_info_t* pathloc) 
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   38798:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))        
    printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
            parent, doff, ino);                                       
                                                                      
  if (ino == RTEMS_RFS_ROOT_INO)                                      
   3879c:	e3550001 	cmp	r5, #1                                        <== NOT EXECUTED
                                                                      
static int                                                            
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
                           rtems_filesystem_location_info_t* pathloc) 
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   387a0:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
   387a4:	e5907000 	ldr	r7, [r0]                                      <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  uint32_t               doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
   387a8:	e5916004 	ldr	r6, [r1, #4]                                  <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))        
    printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
            parent, doff, ino);                                       
                                                                      
  if (ino == RTEMS_RFS_ROOT_INO)                                      
   387ac:	1a000003 	bne	387c0 <rtems_rfs_rtems_dir_rmnod+0x30>        <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);    
   387b0:	eb0011d2 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   387b4:	e3a03010 	mov	r3, #16                                       <== NOT EXECUTED
   387b8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   387bc:	ea000011 	b	38808 <rtems_rfs_rtems_dir_rmnod+0x78>          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
   387c0:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   387c4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   387c8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   387cc:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   387d0:	ebff4c3a 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
   387d4:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   387d8:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
   387dc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   387e0:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   387e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   387e8:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   387ec:	ebfffe46 	bl	3810c <rtems_rfs_unlink>                       <== NOT EXECUTED
  if (rc)                                                             
   387f0:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   387f4:	0a000005 	beq	38810 <rtems_rfs_rtems_dir_rmnod+0x80>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   387f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   387fc:	ebffffdd 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);        
   38800:	eb0011be 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38804:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   38808:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   3880c:	ea000002 	b	3881c <rtems_rfs_rtems_dir_rmnod+0x8c>          <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   38810:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38814:	ebffffd7 	bl	38778 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   38818:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   3881c:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      <== NOT EXECUTED
                                                                      

0001ee68 <rtems_rfs_rtems_eval_for_make>: */ int rtems_rfs_rtems_eval_for_make (const char* path, rtems_filesystem_location_info_t* pathloc, const char** name) {
   1ee68:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1ee6c:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
 */                                                                   
int                                                                   
rtems_rfs_rtems_eval_for_make (const char*                       path,
                               rtems_filesystem_location_info_t* pathloc,
                               const char**                      name)
{                                                                     
   1ee70:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1ee74:	e5911000 	ldr	r1, [r1]                                      <== NOT EXECUTED
 */                                                                   
int                                                                   
rtems_rfs_rtems_eval_for_make (const char*                       path,
                               rtems_filesystem_location_info_t* pathloc,
                               const char**                      name)
{                                                                     
   1ee78:	e24dd040 	sub	sp, sp, #64	; 0x40                            <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1ee7c:	e58d103c 	str	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
  rtems_rfs_ino          node_ino;                                    
  uint32_t               doff = 0;                                    
   1ee80:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 */                                                                   
int                                                                   
rtems_rfs_rtems_eval_for_make (const char*                       path,
                               rtems_filesystem_location_info_t* pathloc,
                               const char**                      name)
{                                                                     
   1ee84:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   1ee88:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_rfs_ino          node_ino;                                    
  uint32_t               doff = 0;                                    
   1ee8c:	e58d1034 	str	r1, [sp, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_eval_for_make (const char*                       path,
                               rtems_filesystem_location_info_t* pathloc,
                               const char**                      name)
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1ee90:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))    
    printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
                                                                      
  *name = path + strlen (path);                                       
   1ee94:	eb009316 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1ee98:	e0880000 	add	r0, r8, r0                                    <== NOT EXECUTED
   1ee9c:	e5870000 	str	r0, [r7]                                      <== NOT EXECUTED
                                                                      
  while (*name != path)                                               
   1eea0:	ea000007 	b	1eec4 <rtems_rfs_rtems_eval_for_make+0x5c>      <== NOT EXECUTED
  {                                                                   
    (*name)--;                                                        
   1eea4:	e5872000 	str	r2, [r7]                                      <== NOT EXECUTED
    if (rtems_filesystem_is_separator (**name))                       
   1eea8:	e5530001 	ldrb	r0, [r3, #-1]                                <== NOT EXECUTED
   1eeac:	ebffa835 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1eeb0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    {                                                                 
      (*name)++;                                                      
   1eeb4:	15973000 	ldrne	r3, [r7]                                    <== NOT EXECUTED
   1eeb8:	12833001 	addne	r3, r3, #1                                  <== NOT EXECUTED
   1eebc:	15873000 	strne	r3, [r7]                                    <== NOT EXECUTED
      break;                                                          
   1eec0:	1a000003 	bne	1eed4 <rtems_rfs_rtems_eval_for_make+0x6c>    <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))    
    printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
                                                                      
  *name = path + strlen (path);                                       
                                                                      
  while (*name != path)                                               
   1eec4:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
   1eec8:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
  {                                                                   
    (*name)--;                                                        
   1eecc:	e2432001 	sub	r2, r3, #1                                    <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))    
    printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
                                                                      
  *name = path + strlen (path);                                       
                                                                      
  while (*name != path)                                               
   1eed0:	1afffff3 	bne	1eea4 <rtems_rfs_rtems_eval_for_make+0x3c>    <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Eat any separators at start of the path.                         
   */                                                                 
  stripped = rtems_filesystem_prefix_separators (path, strlen(path)); 
   1eed4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   1eed8:	eb009305 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1eedc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   1eee0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   1eee4:	ebffa17d 	bl	74e0 <rtems_filesystem_prefix_separators>      <== NOT EXECUTED
  path += stripped;                                                   
   1eee8:	e0888000 	add	r8, r8, r0                                    <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1eeec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1eef0:	ebfffc7a 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
  while (true)                                                        
  {                                                                   
    /*                                                                
     * Open and load the inode.                                       
     */                                                               
    rc = rtems_rfs_inode_open (fs, ino, &inode, true);                
   1eef4:	e28d600c 	add	r6, sp, #12                                   <== NOT EXECUTED
   1eef8:	ea000000 	b	1ef00 <rtems_rfs_rtems_eval_for_make+0x98>      <== NOT EXECUTED
   * Eat any separators at start of the path.                         
   */                                                                 
  stripped = rtems_filesystem_prefix_separators (path, strlen(path)); 
  path += stripped;                                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1eefc:	e1a08009 	mov	r8, r9                                        <== NOT EXECUTED
  while (true)                                                        
  {                                                                   
    /*                                                                
     * Open and load the inode.                                       
     */                                                               
    rc = rtems_rfs_inode_open (fs, ino, &inode, true);                
   1ef00:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ef04:	e59d103c 	ldr	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   1ef08:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1ef0c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1ef10:	eb00629b 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
    if (rc > 0)                                                       
   1ef14:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   1ef18:	da000004 	ble	1ef30 <rtems_rfs_rtems_eval_for_make+0xc8>    <== NOT EXECUTED
    {                                                                 
      rtems_rfs_rtems_unlock (fs);                                    
   1ef1c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ef20:	ebfffc73 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);   
   1ef24:	eb0077f5 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1ef28:	e580a000 	str	sl, [r0]                                      <== NOT EXECUTED
   1ef2c:	ea000012 	b	1ef7c <rtems_rfs_rtems_eval_for_make+0x114>     <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   1ef30:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * If a directory the execute bit must be set for us to enter.    
     */                                                               
    if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&      
   1ef34:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   1ef38:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   1ef3c:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   1ef40:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   1ef44:	1a00000e 	bne	1ef84 <rtems_rfs_rtems_eval_for_make+0x11c>   <== NOT EXECUTED
   1ef48:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1ef4c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1ef50:	eb00018a 	bl	1f580 <rtems_rfs_rtems_eval_perms>             <== NOT EXECUTED
   1ef54:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1ef58:	1a000009 	bne	1ef84 <rtems_rfs_rtems_eval_for_make+0x11c>   <== NOT EXECUTED
        !rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
   1ef5c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1ef60:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ef64:	eb006263 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      rtems_rfs_rtems_unlock (fs);                                    
   1ef68:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ef6c:	ebfffc60 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
   1ef70:	eb0077e2 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1ef74:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
   1ef78:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1ef7c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   1ef80:	ea0000bc 	b	1f278 <rtems_rfs_rtems_eval_for_make+0x410>     <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Is this the end of the pathname we where given ?               
     */                                                               
    if (path == *name)                                                
   1ef84:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
   1ef88:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
   1ef8c:	0a000076 	beq	1f16c <rtems_rfs_rtems_eval_for_make+0x304>   <== NOT EXECUTED
   1ef90:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   1ef94:	ea000000 	b	1ef9c <rtems_rfs_rtems_eval_for_make+0x134>     <== NOT EXECUTED
    node_len = 0;                                                     
    while (!rtems_filesystem_is_separator(*path) &&                   
           (*path != '\0') &&                                         
           (node_len < (rtems_rfs_fs_max_name (fs) - 1)))             
    {                                                                 
      node_len++;                                                     
   1ef98:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
    /*                                                                
     * Extract the node name we will look for this time around.       
     */                                                               
    node = path;                                                      
    node_len = 0;                                                     
    while (!rtems_filesystem_is_separator(*path) &&                   
   1ef9c:	e7d8000a 	ldrb	r0, [r8, sl]                                 <== NOT EXECUTED
   1efa0:	ebffa7f8 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1efa4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
 * @param pathloc                                                     
 * @param name                                                        
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_eval_for_make (const char*                       path,
   1efa8:	e088b00a 	add	fp, r8, sl                                    <== NOT EXECUTED
    /*                                                                
     * Extract the node name we will look for this time around.       
     */                                                               
    node = path;                                                      
    node_len = 0;                                                     
    while (!rtems_filesystem_is_separator(*path) &&                   
   1efac:	1a000006 	bne	1efcc <rtems_rfs_rtems_eval_for_make+0x164>   <== NOT EXECUTED
   1efb0:	e7d8300a 	ldrb	r3, [r8, sl]                                 <== NOT EXECUTED
   1efb4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1efb8:	0a000003 	beq	1efcc <rtems_rfs_rtems_eval_for_make+0x164>   <== NOT EXECUTED
           (*path != '\0') &&                                         
           (node_len < (rtems_rfs_fs_max_name (fs) - 1)))             
   1efbc:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
   1efc0:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
   1efc4:	e15a0003 	cmp	sl, r3                                        <== NOT EXECUTED
   1efc8:	3afffff2 	bcc	1ef98 <rtems_rfs_rtems_eval_for_make+0x130>   <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Eat any separators at start of the new path.                   
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, strlen (path));
   1efcc:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   1efd0:	eb0092c7 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1efd4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   1efd8:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   1efdc:	ebffa13f 	bl	74e0 <rtems_filesystem_prefix_separators>      <== NOT EXECUTED
                                                                      
    /*                                                                
     * If the node is the current directory and there is more path to come move
     * on it else we are at the inode we want.                        
     */                                                               
    if (rtems_rfs_current_dir (node))                                 
   1efe0:	e5d82000 	ldrb	r2, [r8]                                     <== NOT EXECUTED
   1efe4:	e352002e 	cmp	r2, #46	; 0x2e                                <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Eat any separators at start of the new path.                   
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, strlen (path));
   1efe8:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    path += stripped;                                                 
   1efec:	e08b9000 	add	r9, fp, r0                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * If the node is the current directory and there is more path to come move
     * on it else we are at the inode we want.                        
     */                                                               
    if (rtems_rfs_current_dir (node))                                 
   1eff0:	1a00000e 	bne	1f030 <rtems_rfs_rtems_eval_for_make+0x1c8>   <== NOT EXECUTED
   1eff4:	e5d80001 	ldrb	r0, [r8, #1]                                 <== NOT EXECUTED
   1eff8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1effc:	0a000004 	beq	1f014 <rtems_rfs_rtems_eval_for_make+0x1ac>   <== NOT EXECUTED
   1f000:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   1f004:	ebffa7df 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1f008:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f00c:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   1f010:	0a000006 	beq	1f030 <rtems_rfs_rtems_eval_for_make+0x1c8>   <== NOT EXECUTED
    {                                                                 
      if (*path)                                                      
   1f014:	e7db3003 	ldrb	r3, [fp, r3]                                 <== NOT EXECUTED
   1f018:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1f01c:	0a000052 	beq	1f16c <rtems_rfs_rtems_eval_for_make+0x304>   <== NOT EXECUTED
      {                                                               
        rtems_rfs_inode_close (fs, &inode);                           
   1f020:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f024:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f028:	eb006232 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
        continue;                                                     
   1f02c:	eaffffb2 	b	1eefc <rtems_rfs_rtems_eval_for_make+0x94>      <== NOT EXECUTED
    /*                                                                
     * If the node is a parent we must move up one directory. If the location
     * is on another file system we have a crossmount so we call that file
     * system to handle the remainder of the path.                    
     */                                                               
    if (rtems_rfs_parent_dir (path))                                  
   1f030:	e7db3003 	ldrb	r3, [fp, r3]                                 <== NOT EXECUTED
   1f034:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   1f038:	1a000033 	bne	1f10c <rtems_rfs_rtems_eval_for_make+0x2a4>   <== NOT EXECUTED
   1f03c:	e5d93001 	ldrb	r3, [r9, #1]                                 <== NOT EXECUTED
   1f040:	e353002e 	cmp	r3, #46	; 0x2e                                <== NOT EXECUTED
   1f044:	1a000030 	bne	1f10c <rtems_rfs_rtems_eval_for_make+0x2a4>   <== NOT EXECUTED
   1f048:	e5d90002 	ldrb	r0, [r9, #2]                                 <== NOT EXECUTED
   1f04c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f050:	e289b002 	add	fp, r9, #2                                    <== NOT EXECUTED
   1f054:	0a000002 	beq	1f064 <rtems_rfs_rtems_eval_for_make+0x1fc>   <== NOT EXECUTED
   1f058:	ebffa7ca 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1f05c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f060:	0a000029 	beq	1f10c <rtems_rfs_rtems_eval_for_make+0x2a4>   <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * If we are at the root inode of the file system we have a crossmount
       * path.                                                        
       */                                                             
      if (ino == RTEMS_RFS_ROOT_INO)                                  
   1f064:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   1f068:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   1f06c:	1a000013 	bne	1f0c0 <rtems_rfs_rtems_eval_for_make+0x258>   <== NOT EXECUTED
      {                                                               
        if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
          printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
                 path - node_len);                                    
                                                                      
        rtems_rfs_inode_close (fs, &inode);                           
   1f070:	e28d100c 	add	r1, sp, #12                                   <== NOT EXECUTED
   1f074:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f078:	eb00621e 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
        rtems_rfs_rtems_unlock (fs);                                  
   1f07c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f080:	ebfffc1b 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
        *pathloc = pathloc->mt_entry->mt_point_node;                  
   1f084:	e595c010 	ldr	ip, [r5, #16]                                 <== NOT EXECUTED
   1f088:	e28cc008 	add	ip, ip, #8                                    <== NOT EXECUTED
   1f08c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   1f090:	e1a0e005 	mov	lr, r5                                        <== NOT EXECUTED
   1f094:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   1f098:	e59c2000 	ldr	r2, [ip]                                      <== NOT EXECUTED
   1f09c:	e58e2000 	str	r2, [lr]                                      <== NOT EXECUTED
        return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
   1f0a0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1f0a4:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
   1f0a8:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   1f0ac:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1f0b0:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1f0b4:	e593f004 	ldr	pc, [r3, #4]                                  <== NOT EXECUTED
   1f0b8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   1f0bc:	ea00006d 	b	1f278 <rtems_rfs_rtems_eval_for_make+0x410>     <== NOT EXECUTED
   1f0c0:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
                                                                      
      /*                                                              
       * If not a directory give and up return. We cannot change dir from a
       * regular file or device node.                                 
       */                                                             
      if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))     
   1f0c4:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   1f0c8:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   1f0cc:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   1f0d0:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   1f0d4:	0a000007 	beq	1f0f8 <rtems_rfs_rtems_eval_for_make+0x290>   <== NOT EXECUTED
      {                                                               
        rtems_rfs_inode_close (fs, &inode);                           
   1f0d8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f0dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f0e0:	eb006204 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
        rtems_rfs_rtems_unlock (fs);                                  
   1f0e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f0e8:	ebfffc01 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
        return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
   1f0ec:	eb007783 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f0f0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   1f0f4:	eaffff9f 	b	1ef78 <rtems_rfs_rtems_eval_for_make+0x110>     <== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       * We need to find the parent of this node.                     
       */                                                             
      rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
   1f0f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f0fc:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f100:	e59f217c 	ldr	r2, [pc, #380]	; 1f284 <rtems_rfs_rtems_eval_for_make+0x41c><== NOT EXECUTED
   1f104:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   1f108:	ea000003 	b	1f11c <rtems_rfs_rtems_eval_for_make+0x2b4>     <== NOT EXECUTED
    else                                                              
    {                                                                 
      /*                                                              
       * Read the inode so we know it exists and what type it is.     
       */                                                             
      rc = rtems_rfs_dir_lookup_ino (fs, &inode,                      
   1f10c:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   1f110:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   1f114:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f118:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f11c:	e28dc03c 	add	ip, sp, #60	; 0x3c                            <== NOT EXECUTED
   1f120:	e28de034 	add	lr, sp, #52	; 0x34                            <== NOT EXECUTED
   1f124:	e88d5000 	stm	sp, {ip, lr}                                  <== NOT EXECUTED
   1f128:	eb005842 	bl	35238 <rtems_rfs_dir_lookup_ino>               <== NOT EXECUTED
                                     node, node_len - stripped, &ino, &doff);
      if (rc > 0)                                                     
   1f12c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   1f130:	da000003 	ble	1f144 <rtems_rfs_rtems_eval_for_make+0x2dc>   <== NOT EXECUTED
      {                                                               
        rtems_rfs_inode_close (fs, &inode);                           
   1f134:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f138:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f13c:	eb0061ed 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   1f140:	ea000004 	b	1f158 <rtems_rfs_rtems_eval_for_make+0x2f0>     <== NOT EXECUTED
      if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
        printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
               node, ino);                                            
    }                                                                 
                                                                      
    rc = rtems_rfs_inode_close (fs, &inode);                          
   1f144:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f148:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f14c:	eb0061e9 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    if (rc > 0)                                                       
   1f150:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   1f154:	daffff68 	ble	1eefc <rtems_rfs_rtems_eval_for_make+0x94>    <== NOT EXECUTED
    {                                                                 
      rtems_rfs_rtems_unlock (fs);                                    
   1f158:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f15c:	ebfffbe4 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
   1f160:	eb007766 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f164:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   1f168:	eaffff83 	b	1ef7c <rtems_rfs_rtems_eval_for_make+0x114>     <== NOT EXECUTED
   1f16c:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))         
   1f170:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   1f174:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   1f178:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   1f17c:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   1f180:	e28d600c 	add	r6, sp, #12                                   <== NOT EXECUTED
   1f184:	0a000007 	beq	1f1a8 <rtems_rfs_rtems_eval_for_make+0x340>   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   1f188:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f18c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f190:	eb0061d8 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
   1f194:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f198:	ebfffbd5 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR); 
   1f19c:	eb007757 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f1a0:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
   1f1a4:	eaffff73 	b	1ef78 <rtems_rfs_rtems_eval_for_make+0x110>     <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))     
   1f1a8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1f1ac:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
   1f1b0:	eb0000f2 	bl	1f580 <rtems_rfs_rtems_eval_perms>             <== NOT EXECUTED
   1f1b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f1b8:	0affff67 	beq	1ef5c <rtems_rfs_rtems_eval_for_make+0xf4>    <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Make sure the name does not already exists in the directory.     
   */                                                                 
  rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),   
   1f1bc:	e5977000 	ldr	r7, [r7]                                      <== NOT EXECUTED
   1f1c0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1f1c4:	eb00924a 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1f1c8:	e28dc038 	add	ip, sp, #56	; 0x38                            <== NOT EXECUTED
   1f1cc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1f1d0:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1f1d4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1f1d8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f1dc:	e28dc034 	add	ip, sp, #52	; 0x34                            <== NOT EXECUTED
   1f1e0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f1e4:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   1f1e8:	eb005812 	bl	35238 <rtems_rfs_dir_lookup_ino>               <== NOT EXECUTED
                                 &node_ino, &doff);                   
  if (rc == 0)                                                        
   1f1ec:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1f1f0:	1a000007 	bne	1f214 <rtems_rfs_rtems_eval_for_make+0x3ac>   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   1f1f4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f1f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f1fc:	eb0061bd 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
   1f200:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f204:	ebfffbba 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
   1f208:	eb00773c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f20c:	e3a03011 	mov	r3, #17                                       <== NOT EXECUTED
   1f210:	eaffff58 	b	1ef78 <rtems_rfs_rtems_eval_for_make+0x110>     <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rc != ENOENT)                                                   
   1f214:	e3570002 	cmp	r7, #2                                        <== NOT EXECUTED
   1f218:	0a000007 	beq	1f23c <rtems_rfs_rtems_eval_for_make+0x3d4>   <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   1f21c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f220:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f224:	eb0061b3 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
   1f228:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f22c:	ebfffbb0 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("eval_for_make: look up", rc);      
   1f230:	eb007732 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f234:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   1f238:	eaffff4f 	b	1ef7c <rtems_rfs_rtems_eval_for_make+0x114>     <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Set the parent ino in the path location.                         
   */                                                                 
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
   1f23c:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   1f240:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
   1f244:	e59d3034 	ldr	r3, [sp, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f248:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  /*                                                                  
   * Set the parent ino in the path location.                         
   */                                                                 
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
   1f24c:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f250:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f254:	eb0000da 	bl	1f5c4 <rtems_rfs_rtems_set_handlers>           <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))    
    printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
           ino, *name);                                               
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   1f258:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f25c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))    
    printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
           ino, *name);                                               
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   1f260:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f264:	03a05005 	moveq	r5, #5                                      <== NOT EXECUTED
   1f268:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))    
    printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
           ino, *name);                                               
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   1f26c:	eb0061a1 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  rtems_rfs_rtems_unlock (fs);                                        
   1f270:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f274:	ebfffb9e 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
   1f278:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1f27c:	e28dd040 	add	sp, sp, #64	; 0x40                            <== NOT EXECUTED
   1f280:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0001f288 <rtems_rfs_rtems_eval_path>: int rtems_rfs_rtems_eval_path (const char* path, size_t pathlen, int flags, rtems_filesystem_location_info_t* pathloc) {
   1f288:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   1f28c:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1f290:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
   1f294:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1f298:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_eval_path (const char*                       path,    
                           size_t                            pathlen, 
                           int                               flags,   
                           rtems_filesystem_location_info_t* pathloc) 
{                                                                     
   1f29c:	e24dd044 	sub	sp, sp, #68	; 0x44                            <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1f2a0:	e58d3040 	str	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
  uint32_t               doff = 0;                                    
   1f2a4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_eval_path (const char*                       path,    
                           size_t                            pathlen, 
                           int                               flags,   
                           rtems_filesystem_location_info_t* pathloc) 
{                                                                     
   1f2a8:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
   1f2ac:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_inode_handle inode;                                       
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  uint32_t               doff = 0;                                    
   1f2b0:	e58d303c 	str	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_eval_path (const char*                       path,    
                           size_t                            pathlen, 
                           int                               flags,   
                           rtems_filesystem_location_info_t* pathloc) 
{                                                                     
   1f2b4:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
            path, pathlen, ino);                                      
                                                                      
  /*                                                                  
   * Eat any separators at the start of the path.                     
   */                                                                 
  stripped = rtems_filesystem_prefix_separators (path, pathlen);      
   1f2b8:	ebffa088 	bl	74e0 <rtems_filesystem_prefix_separators>      <== NOT EXECUTED
   1f2bc:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  path += stripped;                                                   
  pathlen -= stripped;                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1f2c0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  /*                                                                  
   * Eat any separators at the start of the path.                     
   */                                                                 
  stripped = rtems_filesystem_prefix_separators (path, pathlen);      
  path += stripped;                                                   
  pathlen -= stripped;                                                
   1f2c4:	e0678008 	rsb	r8, r7, r8                                    <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1f2c8:	ebfffb84 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Eat any separators at the start of the path.                     
   */                                                                 
  stripped = rtems_filesystem_prefix_separators (path, pathlen);      
  path += stripped;                                                   
   1f2cc:	e0867007 	add	r7, r6, r7                                    <== NOT EXECUTED
      /*                                                              
       * Look up the node name in this directory. If found drop through, close
       * the current inode and let the loop open the inode so the mode can be
       * read and handlers set.                                       
       */                                                             
      rc = rtems_rfs_dir_lookup_ino (fs, &inode,                      
   1f2d0:	e28d9040 	add	r9, sp, #64	; 0x40                            <== NOT EXECUTED
  while (true)                                                        
  {                                                                   
    /*                                                                
     * Open and load the inode.                                       
     */                                                               
    rc = rtems_rfs_inode_open (fs, ino, &inode, true);                
   1f2d4:	e28d6014 	add	r6, sp, #20                                   <== NOT EXECUTED
   1f2d8:	ea000000 	b	1f2e0 <rtems_rfs_rtems_eval_path+0x58>          <== NOT EXECUTED
   */                                                                 
  stripped = rtems_filesystem_prefix_separators (path, pathlen);      
  path += stripped;                                                   
  pathlen -= stripped;                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1f2dc:	e59d700c 	ldr	r7, [sp, #12]                                 <== NOT EXECUTED
  while (true)                                                        
  {                                                                   
    /*                                                                
     * Open and load the inode.                                       
     */                                                               
    rc = rtems_rfs_inode_open (fs, ino, &inode, true);                
   1f2e0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f2e4:	e59d1040 	ldr	r1, [sp, #64]	; 0x40                          <== NOT EXECUTED
   1f2e8:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1f2ec:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1f2f0:	eb0061a3 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
    if (rc > 0)                                                       
   1f2f4:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   1f2f8:	da000004 	ble	1f310 <rtems_rfs_rtems_eval_path+0x88>        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_rtems_unlock (fs);                                    
   1f2fc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f300:	ebfffb7b 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_path: opening inode", rc);  
   1f304:	eb0076fd 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f308:	e580a000 	str	sl, [r0]                                      <== NOT EXECUTED
   1f30c:	ea000018 	b	1f374 <rtems_rfs_rtems_eval_path+0xec>          <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Is this the end of the pathname we where given ?               
     */                                                               
    if ((*path == '\0') || (pathlen == 0))                            
   1f310:	e5d73000 	ldrb	r3, [r7]                                     <== NOT EXECUTED
   1f314:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   1f318:	13530000 	cmpne	r3, #0                                      <== NOT EXECUTED
   1f31c:	0a000083 	beq	1f530 <rtems_rfs_rtems_eval_path+0x2a8>       <== NOT EXECUTED
   1f320:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
      break;                                                          
                                                                      
    /*                                                                
     * If a directory the execute bit must be set for us to enter.    
     */                                                               
    if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&      
   1f324:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   1f328:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   1f32c:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   1f330:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   1f334:	0a000001 	beq	1f340 <rtems_rfs_rtems_eval_path+0xb8>        <== NOT EXECUTED
   1f338:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
   1f33c:	ea000010 	b	1f384 <rtems_rfs_rtems_eval_path+0xfc>          <== NOT EXECUTED
   1f340:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1f344:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1f348:	eb00008c 	bl	1f580 <rtems_rfs_rtems_eval_perms>             <== NOT EXECUTED
   1f34c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f350:	1afffff8 	bne	1f338 <rtems_rfs_rtems_eval_path+0xb0>        <== NOT EXECUTED
        !rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
   1f354:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f358:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f35c:	eb006165 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      rtems_rfs_rtems_unlock (fs);                                    
   1f360:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f364:	ebfffb62 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES); 
   1f368:	eb0076e4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f36c:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
   1f370:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1f374:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   1f378:	ea00007c 	b	1f570 <rtems_rfs_rtems_eval_path+0x2e8>         <== NOT EXECUTED
    while (!rtems_filesystem_is_separator (*path) &&                  
           (*path != '\0') && pathlen &&                              
           ((node_len + 1) < rtems_rfs_fs_max_name (fs)))             
    {                                                                 
      path++;                                                         
      pathlen--;                                                      
   1f37c:	e2488001 	sub	r8, r8, #1                                    <== NOT EXECUTED
   1f380:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
    /*                                                                
     * Extract the node name we will look for this time around.       
     */                                                               
    node = path;                                                      
    node_len = 0;                                                     
    while (!rtems_filesystem_is_separator (*path) &&                  
   1f384:	e7d7000a 	ldrb	r0, [r7, sl]                                 <== NOT EXECUTED
   1f388:	ebffa6fe 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1f38c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
           (*path != '\0') && pathlen &&                              
           ((node_len + 1) < rtems_rfs_fs_max_name (fs)))             
   1f390:	e28a3001 	add	r3, sl, #1                                    <== NOT EXECUTED
 * @param pathlen                                                     
 * @param flags                                                       
 * @param pathloc                                                     
 */                                                                   
int                                                                   
rtems_rfs_rtems_eval_path (const char*                       path,    
   1f394:	e087b00a 	add	fp, r7, sl                                    <== NOT EXECUTED
    /*                                                                
     * Extract the node name we will look for this time around.       
     */                                                               
    node = path;                                                      
    node_len = 0;                                                     
    while (!rtems_filesystem_is_separator (*path) &&                  
   1f398:	1a000006 	bne	1f3b8 <rtems_rfs_rtems_eval_path+0x130>       <== NOT EXECUTED
   1f39c:	e7d7200a 	ldrb	r2, [r7, sl]                                 <== NOT EXECUTED
   1f3a0:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   1f3a4:	13520000 	cmpne	r2, #0                                      <== NOT EXECUTED
   1f3a8:	0a000002 	beq	1f3b8 <rtems_rfs_rtems_eval_path+0x130>       <== NOT EXECUTED
           (*path != '\0') && pathlen &&                              
           ((node_len + 1) < rtems_rfs_fs_max_name (fs)))             
   1f3ac:	e5942018 	ldr	r2, [r4, #24]                                 <== NOT EXECUTED
   1f3b0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   1f3b4:	3afffff0 	bcc	1f37c <rtems_rfs_rtems_eval_path+0xf4>        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Eat any separators at start of the path.                       
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, pathlen);    
   1f3b8:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1f3bc:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   1f3c0:	ebffa046 	bl	74e0 <rtems_filesystem_prefix_separators>      <== NOT EXECUTED
                                                                      
    /*                                                                
     * If the node is the current directory and there is more path to come move
     * on it else we are at the inode we want.                        
     */                                                               
    if (rtems_rfs_current_dir (node))                                 
   1f3c4:	e5d72000 	ldrb	r2, [r7]                                     <== NOT EXECUTED
   1f3c8:	e352002e 	cmp	r2, #46	; 0x2e                                <== NOT EXECUTED
                                                                      
    /*                                                                
     * Eat any separators at start of the path.                       
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, pathlen);    
    path += stripped;                                                 
   1f3cc:	e08b2000 	add	r2, fp, r0                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Eat any separators at start of the path.                       
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, pathlen);    
   1f3d0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    path += stripped;                                                 
    pathlen -= stripped;                                              
   1f3d4:	e0608008 	rsb	r8, r0, r8                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * Eat any separators at start of the path.                       
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, pathlen);    
    path += stripped;                                                 
   1f3d8:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * If the node is the current directory and there is more path to come move
     * on it else we are at the inode we want.                        
     */                                                               
    if (rtems_rfs_current_dir (node))                                 
   1f3dc:	1a00000e 	bne	1f41c <rtems_rfs_rtems_eval_path+0x194>       <== NOT EXECUTED
   1f3e0:	e5d70001 	ldrb	r0, [r7, #1]                                 <== NOT EXECUTED
   1f3e4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f3e8:	0a000004 	beq	1f400 <rtems_rfs_rtems_eval_path+0x178>       <== NOT EXECUTED
   1f3ec:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   1f3f0:	ebffa6e4 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1f3f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f3f8:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   1f3fc:	0a000006 	beq	1f41c <rtems_rfs_rtems_eval_path+0x194>       <== NOT EXECUTED
    {                                                                 
      if (*path)                                                      
   1f400:	e7db3003 	ldrb	r3, [fp, r3]                                 <== NOT EXECUTED
   1f404:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1f408:	0a000048 	beq	1f530 <rtems_rfs_rtems_eval_path+0x2a8>       <== NOT EXECUTED
      {                                                               
        rtems_rfs_inode_close (fs, &inode);                           
   1f40c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f410:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f414:	eb006137 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
        continue;                                                     
   1f418:	eaffffaf 	b	1f2dc <rtems_rfs_rtems_eval_path+0x54>          <== NOT EXECUTED
    /*                                                                
     * If the node is a parent we must move up one directory. If the location
     * is on another file system we have a crossmount so we call that file
     * system to handle the remainder of the path.                    
     */                                                               
    if (rtems_rfs_parent_dir (node))                                  
   1f41c:	e5d72000 	ldrb	r2, [r7]                                     <== NOT EXECUTED
   1f420:	e352002e 	cmp	r2, #46	; 0x2e                                <== NOT EXECUTED
     * Eat any separators at start of the path.                       
     */                                                               
    stripped = rtems_filesystem_prefix_separators (path, pathlen);    
    path += stripped;                                                 
    pathlen -= stripped;                                              
    node_len += stripped;                                             
   1f424:	e083a00a 	add	sl, r3, sl                                    <== NOT EXECUTED
    /*                                                                
     * If the node is a parent we must move up one directory. If the location
     * is on another file system we have a crossmount so we call that file
     * system to handle the remainder of the path.                    
     */                                                               
    if (rtems_rfs_parent_dir (node))                                  
   1f428:	1a00002a 	bne	1f4d8 <rtems_rfs_rtems_eval_path+0x250>       <== NOT EXECUTED
   1f42c:	e5d72001 	ldrb	r2, [r7, #1]                                 <== NOT EXECUTED
   1f430:	e352002e 	cmp	r2, #46	; 0x2e                                <== NOT EXECUTED
   1f434:	1a000027 	bne	1f4d8 <rtems_rfs_rtems_eval_path+0x250>       <== NOT EXECUTED
   1f438:	e5d70002 	ldrb	r0, [r7, #2]                                 <== NOT EXECUTED
   1f43c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f440:	0a000004 	beq	1f458 <rtems_rfs_rtems_eval_path+0x1d0>       <== NOT EXECUTED
   1f444:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   1f448:	ebffa6ce 	bl	8f88 <rtems_filesystem_is_separator>           <== NOT EXECUTED
   1f44c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f450:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   1f454:	0a00001f 	beq	1f4d8 <rtems_rfs_rtems_eval_path+0x250>       <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * If we are at root inode of the file system we have a crossmount path.
       */                                                             
      if (ino == RTEMS_RFS_ROOT_INO)                                  
   1f458:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
   1f45c:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
   1f460:	1a000015 	bne	1f4bc <rtems_rfs_rtems_eval_path+0x234>       <== NOT EXECUTED
      {                                                               
        if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))  
          printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
                 path - node_len, pathlen + node_len);                
        rtems_rfs_inode_close (fs, &inode);                           
   1f464:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f468:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f46c:	eb006121 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
        rtems_rfs_rtems_unlock (fs);                                  
   1f470:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f474:	ebfffb1e 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
        *pathloc = pathloc->mt_entry->mt_point_node;                  
   1f478:	e595c010 	ldr	ip, [r5, #16]                                 <== NOT EXECUTED
   1f47c:	e28cc008 	add	ip, ip, #8                                    <== NOT EXECUTED
   1f480:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   1f484:	e1a0e005 	mov	lr, r5                                        <== NOT EXECUTED
   1f488:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   1f48c:	e59c2000 	ldr	r2, [ip]                                      <== NOT EXECUTED
   1f490:	e58e2000 	str	r2, [lr]                                      <== NOT EXECUTED
        return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
   1f494:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   1f498:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   1f49c:	e06a0002 	rsb	r0, sl, r2                                    <== NOT EXECUTED
   1f4a0:	e595c00c 	ldr	ip, [r5, #12]                                 <== NOT EXECUTED
   1f4a4:	e08a1008 	add	r1, sl, r8                                    <== NOT EXECUTED
   1f4a8:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
   1f4ac:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   1f4b0:	e59cf000 	ldr	pc, [ip]                                      <== NOT EXECUTED
   1f4b4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   1f4b8:	ea00002c 	b	1f570 <rtems_rfs_rtems_eval_path+0x2e8>         <== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       * We need to find the parent of this node.                     
       */                                                             
      rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
   1f4bc:	e28dc03c 	add	ip, sp, #60	; 0x3c                            <== NOT EXECUTED
   1f4c0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f4c4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f4c8:	e59f20ac 	ldr	r2, [pc, #172]	; 1f57c <rtems_rfs_rtems_eval_path+0x2f4><== NOT EXECUTED
   1f4cc:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
   1f4d0:	e88d1200 	stm	sp, {r9, ip}                                  <== NOT EXECUTED
   1f4d4:	ea000005 	b	1f4f0 <rtems_rfs_rtems_eval_path+0x268>         <== NOT EXECUTED
      /*                                                              
       * Look up the node name in this directory. If found drop through, close
       * the current inode and let the loop open the inode so the mode can be
       * read and handlers set.                                       
       */                                                             
      rc = rtems_rfs_dir_lookup_ino (fs, &inode,                      
   1f4d8:	e28de03c 	add	lr, sp, #60	; 0x3c                            <== NOT EXECUTED
   1f4dc:	e88d4200 	stm	sp, {r9, lr}                                  <== NOT EXECUTED
   1f4e0:	e063300a 	rsb	r3, r3, sl                                    <== NOT EXECUTED
   1f4e4:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1f4e8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f4ec:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f4f0:	eb005750 	bl	35238 <rtems_rfs_dir_lookup_ino>               <== NOT EXECUTED
                                     node, node_len - stripped, &ino, &doff);
      if (rc > 0)                                                     
   1f4f4:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1f4f8:	ca000004 	bgt	1f510 <rtems_rfs_rtems_eval_path+0x288>       <== NOT EXECUTED
      }                                                               
      if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))    
        printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
    }                                                                 
                                                                      
    rc = rtems_rfs_inode_close (fs, &inode);                          
   1f4fc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f500:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f504:	eb0060fb 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    if (rc > 0)                                                       
   1f508:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1f50c:	daffff72 	ble	1f2dc <rtems_rfs_rtems_eval_path+0x54>        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
   1f510:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f514:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f518:	eb0060f6 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      rtems_rfs_rtems_unlock (fs);                                    
   1f51c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f520:	ebfffaf3 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_path: closing node", rc);   
   1f524:	eb007675 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f528:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   1f52c:	eaffff90 	b	1f374 <rtems_rfs_rtems_eval_path+0xec>          <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
   1f530:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
   1f534:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
   1f538:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f53c:	e28d6014 	add	r6, sp, #20                                   <== NOT EXECUTED
      return rtems_rfs_rtems_error ("eval_path: closing node", rc);   
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
   1f540:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f544:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1f548:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f54c:	eb00001c 	bl	1f5c4 <rtems_rfs_rtems_set_handlers>           <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   1f550:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f554:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   1f558:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);                     
  rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);                   
                                                                      
  rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;      
   1f55c:	03a05005 	moveq	r5, #5                                      <== NOT EXECUTED
   1f560:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
   1f564:	eb0060e3 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  rtems_rfs_rtems_unlock (fs);                                        
   1f568:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f56c:	ebfffae0 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))        
    printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);     
                                                                      
  return rc;                                                          
}                                                                     
   1f570:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1f574:	e28dd044 	add	sp, sp, #68	; 0x44                            <== NOT EXECUTED
   1f578:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0001f580 <rtems_rfs_rtems_eval_perms>:
   1f580:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
   * Check if I am owner or a group member or someone else.           
   */                                                                 
  flags_to_test = flags;                                              
                                                                      
  if ((st_uid == 0) || (st_uid == uid))                               
    flags_to_test |= flags << 6;                                      
   1f584:	e1a02181 	lsl	r2, r1, #3                                    <== NOT EXECUTED
   1f588:	e1822301 	orr	r2, r2, r1, lsl #6                            <== NOT EXECUTED
   1f58c:	e1821001 	orr	r1, r2, r1                                    <== NOT EXECUTED
   1f590:	e5d32003 	ldrb	r2, [r3, #3]                                 <== NOT EXECUTED
   1f594:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   1f598:	e1a01b81 	lsl	r1, r1, #23                                   <== NOT EXECUTED
   1f59c:	e1823403 	orr	r3, r2, r3, lsl #8                            <== NOT EXECUTED
   1f5a0:	e1a01ba1 	lsr	r1, r1, #23                                   <== NOT EXECUTED
   1f5a4:	e1110003 	tst	r1, r3                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))       
    printf("rtems-rfs: eval-perms: perms failed\n");                  
                                                                      
  return false;                                                       
}                                                                     
   1f5a8:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
   1f5ac:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
   1f5b0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001e1e4 <rtems_rfs_rtems_fchmod>: * @return int */ int rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc, mode_t mode) {
   1e1e4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
   1e1e8:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1e1ec:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino           ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1e1f0:	e5907000 	ldr	r7, [r0]                                      <== NOT EXECUTED
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,    
                        mode_t                            mode)       
{                                                                     
   1e1f4:	e24dd028 	sub	sp, sp, #40	; 0x28                            <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))           
    printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
            ino, mode);                                               
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e1f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,    
                        mode_t                            mode)       
{                                                                     
   1e1fc:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))           
    printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
            ino, mode);                                               
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e200:	ebffffb6 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e204:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1e208:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e20c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   1e210:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e214:	eb0065da 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   1e218:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
            ino, mode);                                               
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e21c:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
  if (rc)                                                             
   1e220:	0a000004 	beq	1e238 <rtems_rfs_rtems_fchmod+0x54>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e224:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e228:	ebffffb1 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fchmod: opening inode", rc);       
   1e22c:	eb007b33 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e230:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   1e234:	ea000016 	b	1e294 <rtems_rfs_rtems_fchmod+0xb0>             <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   1e238:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e23c:	e5d32002 	ldrb	r2, [r3, #2]                                 <== NOT EXECUTED
   1e240:	e1a02402 	lsl	r2, r2, #8                                    <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("fchmod: not owner", EPERM);        
  }                                                                   
#endif                                                                
                                                                      
  imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
   1e244:	e2022a0f 	and	r2, r2, #61440	; 0xf000                       <== NOT EXECUTED
  imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
   1e248:	e3c66a0f 	bic	r6, r6, #61440	; 0xf000                       <== NOT EXECUTED
   1e24c:	e1826006 	orr	r6, r2, r6                                    <== NOT EXECUTED
   1e250:	e1a06806 	lsl	r6, r6, #16                                   <== NOT EXECUTED
 * @prarm mode The mode.                                              
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->mode, mode);                    
   1e254:	e1a02c26 	lsr	r2, r6, #24                                   <== NOT EXECUTED
   1e258:	e5c32002 	strb	r2, [r3, #2]                                 <== NOT EXECUTED
   1e25c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e260:	e1a06826 	lsr	r6, r6, #16                                   <== NOT EXECUTED
   1e264:	e5c36003 	strb	r6, [r3, #3]                                 <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_set_mode (&inode, imode);                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1e268:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   1e26c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e270:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e274:	e5cd3010 	strb	r3, [sp, #16]                                <== NOT EXECUTED
   1e278:	eb00659e 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   1e27c:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e280:	da000005 	ble	1e29c <rtems_rfs_rtems_fchmod+0xb8>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e284:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e288:	ebffff99 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fchmod: closing inode", rc);       
   1e28c:	eb007b1b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e290:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e294:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e298:	ea000002 	b	1e2a8 <rtems_rfs_rtems_fchmod+0xc4>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e29c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e2a0:	ebffff93 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e2a4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e2a8:	e28dd028 	add	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   1e2ac:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

0001e0d8 <rtems_rfs_rtems_fcntl>: int rtems_rfs_rtems_fcntl (int cmd, rtems_libio_t* iop) { return 0; }
   1e0d8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   1e0dc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001e900 <rtems_rfs_rtems_fdatasync>: int rtems_rfs_rtems_fdatasync (rtems_libio_t* iop) { int rc; rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
   1e900:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
 * @param iop                                                         
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)                        
{                                                                     
   1e904:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int rc;                                                             
                                                                      
  rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
   1e908:	e5930034 	ldr	r0, [r3, #52]	; 0x34                          <== NOT EXECUTED
   1e90c:	eb0056eb 	bl	344c0 <rtems_rfs_buffer_sync>                  <== NOT EXECUTED
  if (rc)                                                             
   1e910:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1e914:	01a00004 	moveq	r0, r4                                      <== NOT EXECUTED
   1e918:	08bd8010 	popeq	{r4, pc}                                    <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
   1e91c:	eb007977 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e920:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
   1e924:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e928:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

00038a24 <rtems_rfs_rtems_file_close>: * @param iop * @return int */ static int rtems_rfs_rtems_file_close (rtems_libio_t* iop) {
   38a24:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_rfs_file_handle* file = iop->file_info;                       
   38a28:	e5905038 	ldr	r5, [r0, #56]	; 0x38                          <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);               
   38a2c:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
   38a30:	e5934098 	ldr	r4, [r3, #152]	; 0x98                         <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
   38a34:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   38a38:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   38a3c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   38a40:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38a44:	ebff4b9d 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))       
    printf("rtems-rfs: file-close: handle:%p\n", file);               
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_file_close (fs, file);                               
   38a48:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   38a4c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38a50:	ebfff439 	bl	35b3c <rtems_rfs_file_close>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   38a54:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   38a58:	da000002 	ble	38a68 <rtems_rfs_rtems_file_close+0x44>       <== NOT EXECUTED
    rc = rtems_rfs_rtems_error ("file-close: file close", rc);        
   38a5c:	eb001127 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38a60:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   38a64:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   38a68:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38a6c:	ebffffe6 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
  return rc;                                                          
}                                                                     
   38a70:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38a74:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

00038b00 <rtems_rfs_rtems_file_ftruncate>: * @return int */ int rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop, rtems_off64_t length) {
   38b00:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_rfs_file_handle* file = iop->file_info;                       
   38b04:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          <== NOT EXECUTED
   38b08:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38b0c:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38b10:	e593307c 	ldr	r3, [r3, #124]	; 0x7c                         <== NOT EXECUTED
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,                   
                                rtems_off64_t  length)                
{                                                                     
   38b14:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   38b18:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   38b1c:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   38b20:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   38b24:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   38b28:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38b2c:	ebff4b63 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))      
    printf("rtems-rfs: file-ftrunc: handle:%p length:%Ld\n", file, length);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  rc = rtems_rfs_file_set_size (file, length);                        
   38b30:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   38b34:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38b38:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   38b3c:	ebfff2b4 	bl	35614 <rtems_rfs_file_set_size>                <== NOT EXECUTED
  if (rc)                                                             
   38b40:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   38b44:	0a000002 	beq	38b54 <rtems_rfs_rtems_file_ftruncate+0x54>   <== NOT EXECUTED
    rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);      
   38b48:	eb0010ec 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38b4c:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   38b50:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
                                                                      
  iop->size = rtems_rfs_file_size (file);                             
   38b54:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38b58:	e2831084 	add	r1, r3, #132	; 0x84                           <== NOT EXECUTED
   38b5c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38b60:	ebffeaa5 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
   38b64:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_file_set_size (file, length);                        
  if (rc)                                                             
    rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);      
                                                                      
  iop->size = rtems_rfs_file_size (file);                             
   38b68:	e9850003 	stmib	r5, {r0, r1}                                <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
   38b6c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38b70:	ebffffa5 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
   38b74:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   38b78:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

00038a04 <rtems_rfs_rtems_file_ioctl>: int rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer) { return 0; }
   38a04:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   38a08:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00038b7c <rtems_rfs_rtems_file_lseek>: */ rtems_off64_t rtems_rfs_rtems_file_lseek (rtems_libio_t* iop, rtems_off64_t offset, int whence) {
   38b7c:	e92d4073 	push	{r0, r1, r4, r5, r6, lr}                     <== NOT EXECUTED
  rtems_rfs_file_handle* file = iop->file_info;                       
   38b80:	e5905038 	ldr	r5, [r0, #56]	; 0x38                          <== NOT EXECUTED
   38b84:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
   38b88:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38b8c:	e593307c 	ldr	r3, [r3, #124]	; 0x7c                         <== NOT EXECUTED
   38b90:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 */                                                                   
rtems_off64_t                                                         
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,                       
                            rtems_off64_t  offset,                    
                            int            whence)                    
{                                                                     
   38b94:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   38b98:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   38b9c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38ba0:	ebff4b46 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))       
    printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
   38ba4:	e284200c 	add	r2, r4, #12                                   <== NOT EXECUTED
   38ba8:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
   38bac:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
   38bb0:	e9230006 	stmdb	r3!, {r1, r2}                               <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_file_seek (file, pos, &pos);                         
   38bb4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38bb8:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   38bbc:	ebfff346 	bl	358dc <rtems_rfs_file_seek>                    <== NOT EXECUTED
  if (rc)                                                             
   38bc0:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   38bc4:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
   38bc8:	0a000006 	beq	38be8 <rtems_rfs_rtems_file_lseek+0x6c>       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                
   38bcc:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38bd0:	ebffff8d 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("file_lseek: lseek", rc);           
   38bd4:	eb0010c9 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38bd8:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
   38bdc:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   38be0:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
   38be4:	ea000003 	b	38bf8 <rtems_rfs_rtems_file_lseek+0x7c>         <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
   38be8:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38bec:	ebffff86 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return iop->offset;                                                 
   38bf0:	e284400c 	add	r4, r4, #12                                   <== NOT EXECUTED
   38bf4:	e8940018 	ldm	r4, {r3, r4}                                  <== NOT EXECUTED
}                                                                     
   38bf8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   38bfc:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
   38c00:	e8bd807c 	pop	{r2, r3, r4, r5, r6, pc}                      <== NOT EXECUTED
                                                                      

00038a78 <rtems_rfs_rtems_file_open>: rtems_rfs_rtems_file_open (rtems_libio_t* iop, const char* pathname, uint32_t flag, uint32_t mode) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   38a78:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_file_open (rtems_libio_t* iop,                        
                           const char*    pathname,                   
                           uint32_t       flag,                       
                           uint32_t       mode)                       
{                                                                     
   38a7c:	e92d4071 	push	{r0, r4, r5, r6, lr}                         <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
   38a80:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
   38a84:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   38a88:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   38a8c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
static int                                                            
rtems_rfs_rtems_file_open (rtems_libio_t* iop,                        
                           const char*    pathname,                   
                           uint32_t       flag,                       
                           uint32_t       mode)                       
{                                                                     
   38a90:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   38a94:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38a98:	ebff4b88 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  ino = rtems_rfs_rtems_get_iop_ino (iop);                            
                                                                      
  rc = rtems_rfs_file_open (fs, ino, flags, &file);                   
   38a9c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38aa0:	e5951038 	ldr	r1, [r5, #56]	; 0x38                          <== NOT EXECUTED
   38aa4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   38aa8:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
   38aac:	ebfff48f 	bl	35cf0 <rtems_rfs_file_open>                    <== NOT EXECUTED
  if (rc > 0)                                                         
   38ab0:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   38ab4:	da000005 	ble	38ad0 <rtems_rfs_rtems_file_open+0x58>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   38ab8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38abc:	ebffffd2 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("file-open: open", rc);             
   38ac0:	eb00110e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38ac4:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   38ac8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   38acc:	ea00000a 	b	38afc <rtems_rfs_rtems_file_open+0x84>          <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))        
    printf("rtems-rfs: file-open: handle:%p\n", file);                
                                                                      
  iop->size = rtems_rfs_file_size (file);                             
   38ad0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   38ad4:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   38ad8:	e2831084 	add	r1, r3, #132	; 0x84                           <== NOT EXECUTED
   38adc:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38ae0:	ebffeac5 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
  iop->file_info = file;                                              
   38ae4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))        
    printf("rtems-rfs: file-open: handle:%p\n", file);                
                                                                      
  iop->size = rtems_rfs_file_size (file);                             
   38ae8:	e9850003 	stmib	r5, {r0, r1}                                <== NOT EXECUTED
  iop->file_info = file;                                              
   38aec:	e5853038 	str	r3, [r5, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   38af0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38af4:	ebffffc4 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   38af8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   38afc:	e8bd8078 	pop	{r3, r4, r5, r6, pc}                          <== NOT EXECUTED
                                                                      

00038d78 <rtems_rfs_rtems_file_read>: */ ssize_t rtems_rfs_rtems_file_read (rtems_libio_t* iop, void* buffer, size_t count) {
   38d78:	e92d47f1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, lr}         <== NOT EXECUTED
  rtems_rfs_file_handle* file = iop->file_info;                       
   38d7c:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          <== NOT EXECUTED
   38d80:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38d84:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38d88:	e593307c 	ldr	r3, [r3, #124]	; 0x7c                         <== NOT EXECUTED
 */                                                                   
ssize_t                                                               
rtems_rfs_rtems_file_read (rtems_libio_t* iop,                        
                           void*          buffer,                     
                           size_t         count)                      
{                                                                     
   38d8c:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
   38d90:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   38d94:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   38d98:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   38d9c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38da0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   38da4:	ebff4ac5 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
   38da8:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38dac:	e2831084 	add	r1, r3, #132	; 0x84                           <== NOT EXECUTED
   38db0:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))        
    printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
   38db4:	e285500c 	add	r5, r5, #12                                   <== NOT EXECUTED
   38db8:	e89500a0 	ldm	r5, {r5, r7}                                  <== NOT EXECUTED
   38dbc:	ebffea0e 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
   38dc0:	e1510007 	cmp	r1, r7                                        <== NOT EXECUTED
   38dc4:	8a000024 	bhi	38e5c <rtems_rfs_rtems_file_read+0xe4>        <== NOT EXECUTED
   38dc8:	1a000001 	bne	38dd4 <rtems_rfs_rtems_file_read+0x5c>        <== NOT EXECUTED
   38dcc:	e1500005 	cmp	r0, r5                                        <== NOT EXECUTED
   38dd0:	8a000021 	bhi	38e5c <rtems_rfs_rtems_file_read+0xe4>        <== NOT EXECUTED
   38dd4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   38dd8:	ea000026 	b	38e78 <rtems_rfs_rtems_file_read+0x100>         <== NOT EXECUTED
  {                                                                   
    while (count)                                                     
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
   38ddc:	ebfff1b5 	bl	354b8 <rtems_rfs_file_io_start>                <== NOT EXECUTED
      if (rc > 0)                                                     
   38de0:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
        break;                                                        
                                                                      
      if (size > count)                                               
        size = count;                                                 
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
   38de4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    while (count)                                                     
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
      if (rc > 0)                                                     
   38de8:	da000002 	ble	38df8 <rtems_rfs_rtems_file_read+0x80>        <== NOT EXECUTED
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
   38dec:	eb001043 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38df0:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   38df4:	ea000016 	b	38e54 <rtems_rfs_rtems_file_read+0xdc>          <== NOT EXECUTED
        break;                                                        
      }                                                               
                                                                      
      if (size == 0)                                                  
   38df8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   38dfc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   38e00:	0a00001c 	beq	38e78 <rtems_rfs_rtems_file_read+0x100>       <== NOT EXECUTED
        break;                                                        
                                                                      
      if (size > count)                                               
   38e04:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
        size = count;                                                 
   38e08:	858d6000 	strhi	r6, [sp]                                    <== NOT EXECUTED
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
   38e0c:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   38e10:	e5931020 	ldr	r1, [r3, #32]                                 <== NOT EXECUTED
   38e14:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
   38e18:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   38e1c:	e0811003 	add	r1, r1, r3                                    <== NOT EXECUTED
   38e20:	eb001ce6 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
      data  += size;                                                  
   38e24:	e59d7000 	ldr	r7, [sp]                                      <== NOT EXECUTED
      count -= size;                                                  
      read  += size;                                                  
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
   38e28:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38e2c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   38e30:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
   38e34:	ebfff2d8 	bl	3599c <rtems_rfs_file_io_end>                  <== NOT EXECUTED
      if (rc > 0)                                                     
   38e38:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
                                                                      
      data  += size;                                                  
      count -= size;                                                  
      read  += size;                                                  
   38e3c:	d0855007 	addle	r5, r5, r7                                  <== NOT EXECUTED
      if (size > count)                                               
        size = count;                                                 
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
                                                                      
      data  += size;                                                  
   38e40:	d0888007 	addle	r8, r8, r7                                  <== NOT EXECUTED
      count -= size;                                                  
   38e44:	d0676006 	rsble	r6, r7, r6                                  <== NOT EXECUTED
   38e48:	da000005 	ble	38e64 <rtems_rfs_rtems_file_read+0xec>        <== NOT EXECUTED
      read  += size;                                                  
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
      if (rc > 0)                                                     
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-end", rc); 
   38e4c:	eb00102b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38e50:	e5809000 	str	r9, [r0]                                      <== NOT EXECUTED
   38e54:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   38e58:	ea000006 	b	38e78 <rtems_rfs_rtems_file_read+0x100>         <== NOT EXECUTED
                           void*          buffer,                     
                           size_t         count)                      
{                                                                     
  rtems_rfs_file_handle* file = iop->file_info;                       
  rtems_rfs_pos          pos;                                         
  uint8_t*               data = buffer;                               
   38e5c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
  {                                                                   
    while (count)                                                     
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
   38e60:	e1a0a00d 	mov	sl, sp                                        <== NOT EXECUTED
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
  {                                                                   
    while (count)                                                     
   38e64:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
   38e68:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   38e6c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38e70:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
  {                                                                   
    while (count)                                                     
   38e74:	1affffd8 	bne	38ddc <rtems_rfs_rtems_file_read+0x64>        <== NOT EXECUTED
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
   38e78:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38e7c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38e80:	ebfffee1 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return read;                                                        
}                                                                     
   38e84:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   38e88:	e8bd87f8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, pc}          <== NOT EXECUTED
                                                                      

00038c04 <rtems_rfs_rtems_file_write>: */ ssize_t rtems_rfs_rtems_file_write (rtems_libio_t* iop, const void* buffer, size_t count) {
   38c04:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     <== NOT EXECUTED
  rtems_rfs_file_handle* file = iop->file_info;                       
   38c08:	e5904038 	ldr	r4, [r0, #56]	; 0x38                          <== NOT EXECUTED
   38c0c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38c10:	e5933098 	ldr	r3, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38c14:	e593307c 	ldr	r3, [r3, #124]	; 0x7c                         <== NOT EXECUTED
 */                                                                   
ssize_t                                                               
rtems_rfs_rtems_file_write (rtems_libio_t* iop,                       
                            const void*    buffer,                    
                            size_t         count)                     
{                                                                     
   38c18:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
   38c1c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   38c20:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   38c24:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   38c28:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   38c2c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   38c30:	ebff4b22 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
   * size of file we are still past the end of the file as positions number
   * from 0. For a specific position we need a file that has a length of one
   * more.                                                            
   */                                                                 
                                                                      
  if (pos >= rtems_rfs_file_size (file))                              
   38c34:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38c38:	e2831084 	add	r1, r3, #132	; 0x84                           <== NOT EXECUTED
   38c3c:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))       
    printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
   38c40:	e286800c 	add	r8, r6, #12                                   <== NOT EXECUTED
   38c44:	e8980180 	ldm	r8, {r7, r8}                                  <== NOT EXECUTED
   38c48:	ebffea6b 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
   * size of file we are still past the end of the file as positions number
   * from 0. For a specific position we need a file that has a length of one
   * more.                                                            
   */                                                                 
                                                                      
  if (pos >= rtems_rfs_file_size (file))                              
   38c4c:	e1510008 	cmp	r1, r8                                        <== NOT EXECUTED
   38c50:	8a000011 	bhi	38c9c <rtems_rfs_rtems_file_write+0x98>       <== NOT EXECUTED
   38c54:	1a000001 	bne	38c60 <rtems_rfs_rtems_file_write+0x5c>       <== NOT EXECUTED
   38c58:	e1500007 	cmp	r0, r7                                        <== NOT EXECUTED
   38c5c:	8a00000e 	bhi	38c9c <rtems_rfs_rtems_file_write+0x98>       <== NOT EXECUTED
  {                                                                   
    rc = rtems_rfs_file_set_size (file, pos + 1);                     
   38c60:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   38c64:	e0911007 	adds	r1, r1, r7                                   <== NOT EXECUTED
   38c68:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   38c6c:	e0a22008 	adc	r2, r2, r8                                    <== NOT EXECUTED
   38c70:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38c74:	ebfff266 	bl	35614 <rtems_rfs_file_set_size>                <== NOT EXECUTED
    if (rc)                                                           
   38c78:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   38c7c:	0a000006 	beq	38c9c <rtems_rfs_rtems_file_write+0x98>       <== NOT EXECUTED
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
   38c80:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38c84:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38c88:	ebffff5f 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
      return rtems_rfs_rtems_error ("file-write: write extend", rc);  
   38c8c:	eb00109b 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38c90:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   38c94:	e5809000 	str	r9, [r0]                                      <== NOT EXECUTED
   38c98:	ea000034 	b	38d70 <rtems_rfs_rtems_file_write+0x16c>        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_file_set_bpos (file, pos);                                
   38c9c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38ca0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   38ca4:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38ca8:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   38cac:	e2843010 	add	r3, r4, #16                                   <== NOT EXECUTED
   38cb0:	ebffea22 	bl	33540 <rtems_rfs_block_get_bpos>               <== NOT EXECUTED
   38cb4:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
                                                                      
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
   38cb8:	e1a0900d 	mov	r9, sp                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_file_set_bpos (file, pos);                                
                                                                      
  while (count)                                                       
   38cbc:	ea00001e 	b	38d3c <rtems_rfs_rtems_file_write+0x138>        <== NOT EXECUTED
  {                                                                   
    size_t size = count;                                              
   38cc0:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
   38cc4:	ebfff1fb 	bl	354b8 <rtems_rfs_file_io_start>                <== NOT EXECUTED
    if (rc)                                                           
   38cc8:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
    }                                                                 
                                                                      
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
   38ccc:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
    if (rc)                                                           
   38cd0:	0a000002 	beq	38ce0 <rtems_rfs_rtems_file_write+0xdc>       <== NOT EXECUTED
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write open", rc);   
   38cd4:	eb001089 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38cd8:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   38cdc:	ea000011 	b	38d28 <rtems_rfs_rtems_file_write+0x124>        <== NOT EXECUTED
      break;                                                          
    }                                                                 
                                                                      
    if (size > count)                                                 
   38ce0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
   38ce4:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
      size = count;                                                   
   38ce8:	858d5000 	strhi	r5, [sp]                                    <== NOT EXECUTED
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
   38cec:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   38cf0:	e5930020 	ldr	r0, [r3, #32]                                 <== NOT EXECUTED
   38cf4:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
   38cf8:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
   38cfc:	e0800003 	add	r0, r0, r3                                    <== NOT EXECUTED
   38d00:	eb001d2e 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
                                                                      
    data  += size;                                                    
   38d04:	e59d8000 	ldr	r8, [sp]                                      <== NOT EXECUTED
    count -= size;                                                    
    write  += size;                                                   
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
   38d08:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38d0c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   38d10:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   38d14:	ebfff320 	bl	3599c <rtems_rfs_file_io_end>                  <== NOT EXECUTED
    if (rc)                                                           
   38d18:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   38d1c:	0a000003 	beq	38d30 <rtems_rfs_rtems_file_write+0x12c>      <== NOT EXECUTED
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
   38d20:	eb001076 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   38d24:	e580b000 	str	fp, [r0]                                      <== NOT EXECUTED
   38d28:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
   38d2c:	ea000007 	b	38d50 <rtems_rfs_rtems_file_write+0x14c>        <== NOT EXECUTED
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
    count -= size;                                                    
    write  += size;                                                   
   38d30:	e0877008 	add	r7, r7, r8                                    <== NOT EXECUTED
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
   38d34:	e08aa008 	add	sl, sl, r8                                    <== NOT EXECUTED
    count -= size;                                                    
   38d38:	e0685005 	rsb	r5, r8, r5                                    <== NOT EXECUTED
                                                                      
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
   38d3c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_file_set_bpos (file, pos);                                
                                                                      
  while (count)                                                       
   38d40:	e1550002 	cmp	r5, r2                                        <== NOT EXECUTED
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
   38d44:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   38d48:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_file_set_bpos (file, pos);                                
                                                                      
  while (count)                                                       
   38d4c:	1affffdb 	bne	38cc0 <rtems_rfs_rtems_file_write+0xbc>       <== NOT EXECUTED
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  iop->size = rtems_rfs_file_size (file);                             
   38d50:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
   38d54:	e2831084 	add	r1, r3, #132	; 0x84                           <== NOT EXECUTED
   38d58:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38d5c:	ebffea26 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
   38d60:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  iop->size = rtems_rfs_file_size (file);                             
   38d64:	e9860003 	stmib	r6, {r0, r1}                                <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
   38d68:	e5930098 	ldr	r0, [r3, #152]	; 0x98                         <== NOT EXECUTED
   38d6c:	ebffff26 	bl	38a0c <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return write;                                                       
}                                                                     
   38d70:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   38d74:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

0001e0d0 <rtems_rfs_rtems_freenodinfo>: int rtems_rfs_rtems_freenodinfo (rtems_filesystem_location_info_t* pathloc) { return 0; }
   1e0d0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   1e0d4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001f5b4 <rtems_rfs_rtems_imode>: return true; } uint16_t rtems_rfs_rtems_imode (mode_t mode) {
   1f5b4:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
  /*                                                                  
   * Mapping matches RTEMS so no need to change.                      
   */                                                                 
  return mode;                                                        
}                                                                     
   1f5b8:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
   1f5bc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001e4ac <rtems_rfs_rtems_initialise>: */ int rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry, const void* data) {
   1e4ac:	e92d45f3 	push	{r0, r1, r4, r5, r6, r7, r8, sl, lr}         <== NOT EXECUTED
   1e4b0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   1e4b4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  rtems_rfs_rtems_private* rtems;                                     
  rtems_rfs_file_system*   fs;                                        
  uint32_t                 flags = 0;                                 
  uint32_t                 max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
  const char*              options = data;                            
   1e4b8:	e3a07005 	mov	r7, #5                                        <== NOT EXECUTED
   1e4bc:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
   1e4c0:	ea000024 	b	1e558 <rtems_rfs_rtems_initialise+0xac>         <== NOT EXECUTED
  {                                                                   
    printf ("options=%s\n", options);                                 
   1e4c4:	eb008beb 	bl	41478 <printf>                                 <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
   1e4c8:	e59f1180 	ldr	r1, [pc, #384]	; 1e650 <rtems_rfs_rtems_initialise+0x1a4><== NOT EXECUTED
   1e4cc:	e3a0200c 	mov	r2, #12                                       <== NOT EXECUTED
   1e4d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e4d4:	eb0095d0 	bl	43c1c <strncmp>                                <== NOT EXECUTED
   1e4d8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
   1e4dc:	e59f1170 	ldr	r1, [pc, #368]	; 1e654 <rtems_rfs_rtems_initialise+0x1a8><== NOT EXECUTED
   1e4e0:	e3a0200e 	mov	r2, #14                                       <== NOT EXECUTED
   1e4e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
    if (strncmp (options, "hold-bitmaps",                             
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
   1e4e8:	03866001 	orreq	r6, r6, #1                                  <== NOT EXECUTED
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
    if (strncmp (options, "hold-bitmaps",                             
   1e4ec:	0a000011 	beq	1e538 <rtems_rfs_rtems_initialise+0x8c>       <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
   1e4f0:	eb0095c9 	bl	43c1c <strncmp>                                <== NOT EXECUTED
   1e4f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
   1e4f8:	e59f1158 	ldr	r1, [pc, #344]	; 1e658 <rtems_rfs_rtems_initialise+0x1ac><== NOT EXECUTED
   1e4fc:	e3a0200d 	mov	r2, #13                                       <== NOT EXECUTED
   1e500:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
   1e504:	03866002 	orreq	r6, r6, #2                                  <== NOT EXECUTED
  {                                                                   
    printf ("options=%s\n", options);                                 
    if (strncmp (options, "hold-bitmaps",                             
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
   1e508:	0a00000a 	beq	1e538 <rtems_rfs_rtems_initialise+0x8c>       <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
   1e50c:	eb0095c2 	bl	43c1c <strncmp>                                <== NOT EXECUTED
   1e510:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   1e514:	1a000004 	bne	1e52c <rtems_rfs_rtems_initialise+0x80>       <== NOT EXECUTED
                      sizeof ("max-held-bufs") - 1) == 0)             
    {                                                                 
      max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
   1e518:	e284000e 	add	r0, r4, #14                                   <== NOT EXECUTED
   1e51c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1e520:	eb009a8f 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1e524:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   1e528:	ea000002 	b	1e538 <rtems_rfs_rtems_initialise+0x8c>         <== NOT EXECUTED
    }                                                                 
    else                                                              
      return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
   1e52c:	eb007a73 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e530:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1e534:	ea000011 	b	1e580 <rtems_rfs_rtems_initialise+0xd4>         <== NOT EXECUTED
                                                                      
    options = strchr (options, ',');                                  
   1e538:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e53c:	e3a0102c 	mov	r1, #44	; 0x2c                                <== NOT EXECUTED
   1e540:	eb00929c 	bl	42fb8 <strchr>                                 <== NOT EXECUTED
    if (options)                                                      
   1e544:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1e548:	0a000006 	beq	1e568 <rtems_rfs_rtems_initialise+0xbc>       <== NOT EXECUTED
    {                                                                 
      ++options;                                                      
      if (*options == '\0')                                           
   1e54c:	e5f43001 	ldrb	r3, [r4, #1]!                                <== NOT EXECUTED
   1e550:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1e554:	0a000003 	beq	1e568 <rtems_rfs_rtems_initialise+0xbc>       <== NOT EXECUTED
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
   1e558:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
  {                                                                   
    printf ("options=%s\n", options);                                 
   1e55c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1e560:	e59f00f4 	ldr	r0, [pc, #244]	; 1e65c <rtems_rfs_rtems_initialise+0x1b0><== NOT EXECUTED
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
   1e564:	1affffd6 	bne	1e4c4 <rtems_rfs_rtems_initialise+0x18>       <== NOT EXECUTED
      if (*options == '\0')                                           
        options = NULL;                                               
    }                                                                 
  }                                                                   
                                                                      
  rtems = malloc (sizeof (rtems_rfs_rtems_private));                  
   1e568:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
   1e56c:	ebffa5f7 	bl	7d50 <malloc>                                  <== NOT EXECUTED
  if (!rtems)                                                         
   1e570:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1e574:	1a000004 	bne	1e58c <rtems_rfs_rtems_initialise+0xe0>       <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);  
   1e578:	eb007a60 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e57c:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
   1e580:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1e584:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e588:	ea000025 	b	1e624 <rtems_rfs_rtems_initialise+0x178>        <== NOT EXECUTED
                                                                      
  memset (rtems, 0, sizeof (rtems_rfs_rtems_private));                
   1e58c:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
   1e590:	e5848000 	str	r8, [r4]                                      <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_mutex_create (&rtems->access);                       
   1e594:	eb0067bc 	bl	3848c <rtems_rfs_mutex_create>                 <== NOT EXECUTED
  if (rc > 0)                                                         
   1e598:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   1e59c:	da000004 	ble	1e5b4 <rtems_rfs_rtems_initialise+0x108>      <== NOT EXECUTED
  {                                                                   
    free (rtems);                                                     
   1e5a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e5a4:	ebffa442 	bl	76b4 <free>                                    <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
   1e5a8:	eb007a54 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e5ac:	e580a000 	str	sl, [r0]                                      <== NOT EXECUTED
   1e5b0:	eafffff3 	b	1e584 <rtems_rfs_rtems_initialise+0xd8>         <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
   1e5b4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1e5b8:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   1e5bc:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   1e5c0:	ebffb4be 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
   1e5c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1e5c8:	0a000016 	beq	1e628 <rtems_rfs_rtems_initialise+0x17c>      <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_mutex_lock (&rtems->access);                         
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_mutex_destroy (&rtems->access);                         
   1e5cc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e5d0:	eb0067a6 	bl	38470 <rtems_rfs_mutex_destroy>                <== NOT EXECUTED
    free (rtems);                                                     
   1e5d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e5d8:	ebffa435 	bl	76b4 <free>                                    <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
   1e5dc:	eb007a47 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e5e0:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
   1e5e4:	eaffffe5 	b	1e580 <rtems_rfs_rtems_initialise+0xd4>         <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
  if (rc)                                                             
  {                                                                   
    free (rtems);                                                     
   1e5e8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e5ec:	ebffa430 	bl	76b4 <free>                                    <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: open", rc);            
   1e5f0:	eb007a42 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e5f4:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   1e5f8:	eaffffe1 	b	1e584 <rtems_rfs_rtems_initialise+0xd8>         <== NOT EXECUTED
                                                                      
  mt_entry->fs_info = fs;                                             
                                                                      
  mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;      
  mt_entry->mt_fs_root.handlers    = &rtems_rfs_rtems_dir_handlers;   
  mt_entry->mt_fs_root.ops         = &rtems_rfs_ops;                  
   1e5fc:	e59f305c 	ldr	r3, [pc, #92]	; 1e660 <rtems_rfs_rtems_initialise+0x1b4><== NOT EXECUTED
   1e600:	e5853028 	str	r3, [r5, #40]	; 0x28                          <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info = fs;                                             
                                                                      
  mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;      
   1e604:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
  {                                                                   
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info = fs;                                             
   1e608:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;      
   1e60c:	e585301c 	str	r3, [r5, #28]                                 <== NOT EXECUTED
  mt_entry->mt_fs_root.handlers    = &rtems_rfs_rtems_dir_handlers;   
   1e610:	e59f304c 	ldr	r3, [pc, #76]	; 1e664 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
  {                                                                   
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info = fs;                                             
   1e614:	e5850034 	str	r0, [r5, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;      
  mt_entry->mt_fs_root.handlers    = &rtems_rfs_rtems_dir_handlers;   
   1e618:	e5853024 	str	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
  mt_entry->mt_fs_root.ops         = &rtems_rfs_ops;                  
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e61c:	ebfffeb4 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e620:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e624:	e8bd85fc 	pop	{r2, r3, r4, r5, r6, r7, r8, sl, pc}          <== NOT EXECUTED
    rtems_rfs_mutex_destroy (&rtems->access);                         
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
   1e628:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1e62c:	e5950070 	ldr	r0, [r5, #112]	; 0x70                         <== NOT EXECUTED
   1e630:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
   1e634:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   1e638:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1e63c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1e640:	eb005e5b 	bl	35fb4 <rtems_rfs_fs_open>                      <== NOT EXECUTED
  if (rc)                                                             
   1e644:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1e648:	1affffe6 	bne	1e5e8 <rtems_rfs_rtems_initialise+0x13c>      <== NOT EXECUTED
   1e64c:	eaffffea 	b	1e5fc <rtems_rfs_rtems_initialise+0x150>        <== NOT EXECUTED
                                                                      

0001e700 <rtems_rfs_rtems_link>: */ int rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc, rtems_filesystem_location_info_t* parent_loc, const char* name) {
   1e700:	e92d40f3 	push	{r0, r1, r4, r5, r6, r7, lr}                 <== NOT EXECUTED
   1e704:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);   
   1e708:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
   1e70c:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
 */                                                                   
int                                                                   
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,       
                      rtems_filesystem_location_info_t* parent_loc,   
                      const char*                       name)         
{                                                                     
   1e710:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))             
    printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
            parent, target);                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e714:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,       
                      rtems_filesystem_location_info_t* parent_loc,   
                      const char*                       name)         
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);   
  rtems_rfs_ino          target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
   1e718:	e5935000 	ldr	r5, [r3]                                      <== NOT EXECUTED
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
   1e71c:	e5916000 	ldr	r6, [r1]                                      <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))             
    printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
            parent, target);                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e720:	ebfffe6e 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
   1e724:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1e728:	eb0094f1 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1e72c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1e730:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   1e734:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1e738:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   1e73c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e740:	e88d1020 	stm	sp, {r5, ip}                                  <== NOT EXECUTED
   1e744:	eb0066f2 	bl	38314 <rtems_rfs_link>                         <== NOT EXECUTED
  if (rc)                                                             
   1e748:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e74c:	0a000005 	beq	1e768 <rtems_rfs_rtems_link+0x68>             <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e750:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e754:	ebfffe66 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("link: linking", rc);               
   1e758:	eb0079e8 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e75c:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e760:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e764:	ea000002 	b	1e774 <rtems_rfs_rtems_link+0x74>               <== NOT EXECUTED
	}                                                                    
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e768:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e76c:	ebfffe60 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e770:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
	return 0;                                                            
}                                                                     
   1e774:	e8bd80fc 	pop	{r2, r3, r4, r5, r6, r7, pc}                  <== NOT EXECUTED
                                                                      

0001e0e0 <rtems_rfs_rtems_lock>: */ static inline int rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex) { #if __rtems__ rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
   1e0e0:	e590307c 	ldr	r3, [r0, #124]	; 0x7c                         <== NOT EXECUTED
   1e0e4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1e0e8:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   1e0ec:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1e0f0:	eaffb5f2 	b	b8c0 <rtems_semaphore_obtain>                   <== NOT EXECUTED
                                                                      

0001e92c <rtems_rfs_rtems_mknod>: int rtems_rfs_rtems_mknod (const char *name, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc) {
   1e92c:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
   1e930:	e24dd040 	sub	sp, sp, #64	; 0x40                            <== NOT EXECUTED
   1e934:	e59dc060 	ldr	ip, [sp, #96]	; 0x60                          <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
   1e938:	e59ce010 	ldr	lr, [ip, #16]                                 <== NOT EXECUTED
   1e93c:	e59e4034 	ldr	r4, [lr, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_mknod (const char                       *name,        
                       mode_t                            mode,        
                       dev_t                             dev,         
                       rtems_filesystem_location_info_t *pathloc)     
{                                                                     
   1e940:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e944:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_mknod (const char                       *name,        
                       mode_t                            mode,        
                       dev_t                             dev,         
                       rtems_filesystem_location_info_t *pathloc)     
{                                                                     
   1e948:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
  rtems_rfs_ino           parent = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1e94c:	e59c9000 	ldr	r9, [ip]                                      <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_mknod (const char                       *name,        
                       mode_t                            mode,        
                       dev_t                             dev,         
                       rtems_filesystem_location_info_t *pathloc)     
{                                                                     
   1e950:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
   1e954:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e958:	ebfffde0 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),       
   1e95c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1e960:	eb009463 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1e964:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
                               rtems_rfs_rtems_imode (mode),          
   1e968:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   1e96c:	eb000310 	bl	1f5b4 <rtems_rfs_rtems_imode>                  <== NOT EXECUTED
  gid = 0;                                                            
#endif                                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),       
   1e970:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1e974:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   1e978:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1e97c:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   1e980:	e28de03c 	add	lr, sp, #60	; 0x3c                            <== NOT EXECUTED
   1e984:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1e988:	e3a07001 	mov	r7, #1                                        <== NOT EXECUTED
   1e98c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e990:	e58dc00c 	str	ip, [sp, #12]                                 <== NOT EXECUTED
   1e994:	e58de010 	str	lr, [sp, #16]                                 <== NOT EXECUTED
   1e998:	e98d1080 	stmib	sp, {r7, ip}                                <== NOT EXECUTED
   1e99c:	eb00645a 	bl	37b0c <rtems_rfs_inode_create>                 <== NOT EXECUTED
                               rtems_rfs_rtems_imode (mode),          
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
   1e9a0:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   1e9a4:	da000004 	ble	1e9bc <rtems_rfs_rtems_mknod+0x90>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e9a8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e9ac:	ebfffdd0 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: inode create", rc);         
   1e9b0:	eb007952 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e9b4:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   1e9b8:	ea00000b 	b	1e9ec <rtems_rfs_rtems_mknod+0xc0>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e9bc:	e28d8014 	add	r8, sp, #20                                   <== NOT EXECUTED
   1e9c0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e9c4:	e59d103c 	ldr	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   1e9c8:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   1e9cc:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
   1e9d0:	eb0063eb 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   1e9d4:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   1e9d8:	da000005 	ble	1e9f4 <rtems_rfs_rtems_mknod+0xc8>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e9dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e9e0:	ebfffdc3 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: inode open", rc);           
   1e9e4:	eb007945 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e9e8:	e5809000 	str	r9, [r0]                                      <== NOT EXECUTED
   1e9ec:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e9f0:	ea000034 	b	1eac8 <rtems_rfs_rtems_mknod+0x19c>             <== NOT EXECUTED
  }                                                                   
                                                                      
  if (S_ISDIR(mode) || S_ISREG(mode))                                 
   1e9f4:	e20aaa0f 	and	sl, sl, #61440	; 0xf000                       <== NOT EXECUTED
   1e9f8:	e35a0901 	cmp	sl, #16384	; 0x4000                           <== NOT EXECUTED
   1e9fc:	135a0902 	cmpne	sl, #32768	; 0x8000                         <== NOT EXECUTED
   1ea00:	0a000023 	beq	1ea94 <rtems_rfs_rtems_mknod+0x168>           <== NOT EXECUTED
  {                                                                   
  }                                                                   
  else if (S_ISCHR (mode) || S_ISBLK (mode))                          
   1ea04:	e35a0a02 	cmp	sl, #8192	; 0x2000                            <== NOT EXECUTED
   1ea08:	135a0a06 	cmpne	sl, #24576	; 0x6000                         <== NOT EXECUTED
   1ea0c:	1a000017 	bne	1ea70 <rtems_rfs_rtems_mknod+0x144>           <== NOT EXECUTED
 * @param bno The block number.                                       
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);       
   1ea10:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea14:	e1a02c26 	lsr	r2, r6, #24                                   <== NOT EXECUTED
   1ea18:	e5c3201c 	strb	r2, [r3, #28]                                <== NOT EXECUTED
   1ea1c:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea20:	e1a02826 	lsr	r2, r6, #16                                   <== NOT EXECUTED
   1ea24:	e5c3201d 	strb	r2, [r3, #29]                                <== NOT EXECUTED
   1ea28:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea2c:	e1a02426 	lsr	r2, r6, #8                                    <== NOT EXECUTED
   1ea30:	e5c3201e 	strb	r2, [r3, #30]                                <== NOT EXECUTED
   1ea34:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea38:	e5c3601f 	strb	r6, [r3, #31]                                <== NOT EXECUTED
   1ea3c:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea40:	e1a02c25 	lsr	r2, r5, #24                                   <== NOT EXECUTED
   1ea44:	e5c32020 	strb	r2, [r3, #32]                                <== NOT EXECUTED
   1ea48:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea4c:	e1a02825 	lsr	r2, r5, #16                                   <== NOT EXECUTED
   1ea50:	e5c32021 	strb	r2, [r3, #33]	; 0x21                         <== NOT EXECUTED
   1ea54:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea58:	e1a02425 	lsr	r2, r5, #8                                    <== NOT EXECUTED
   1ea5c:	e5c32022 	strb	r2, [r3, #34]	; 0x22                         <== NOT EXECUTED
   1ea60:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
   1ea64:	e5c35023 	strb	r5, [r3, #35]	; 0x23                         <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   1ea68:	e5cd7024 	strb	r7, [sp, #36]	; 0x24                         <== NOT EXECUTED
   1ea6c:	ea000008 	b	1ea94 <rtems_rfs_rtems_mknod+0x168>             <== NOT EXECUTED
    rtems_rfs_inode_set_block (&inode, 0, major);                     
    rtems_rfs_inode_set_block (&inode, 1, minor);                     
  }                                                                   
  else                                                                
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   1ea70:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1ea74:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ea78:	eb00639e 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
   1ea7c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ea80:	ebfffd9b 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);         
   1ea84:	eb00791d 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1ea88:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   1ea8c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1ea90:	eaffffd5 	b	1e9ec <rtems_rfs_rtems_mknod+0xc0>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1ea94:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ea98:	e28d1014 	add	r1, sp, #20                                   <== NOT EXECUTED
   1ea9c:	eb006395 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   1eaa0:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1eaa4:	da000004 	ble	1eabc <rtems_rfs_rtems_mknod+0x190>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1eaa8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1eaac:	ebfffd90 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: closing inode", rc);        
   1eab0:	eb007912 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1eab4:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1eab8:	eaffffcb 	b	1e9ec <rtems_rfs_rtems_mknod+0xc0>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1eabc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1eac0:	ebfffd8b 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1eac4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   1eac8:	e28dd040 	add	sp, sp, #64	; 0x40                            <== NOT EXECUTED
   1eacc:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

0001f5c0 <rtems_rfs_rtems_mode>: { /* * Mapping matches RTEMS so no need to change. */ return imode; }
   1f5c0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

0001e3a8 <rtems_rfs_rtems_node_type>: * @return rtems_filesystem_node_types_t */ rtems_filesystem_node_types_t rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc) {
   1e3a8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (pathloc);
   1e3ac:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1e3b0:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1e3b4:	e5905000 	ldr	r5, [r0]                                      <== NOT EXECUTED
 * @return rtems_filesystem_node_types_t                              
 */                                                                   
                                                                      
rtems_filesystem_node_types_t                                         
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc) 
{                                                                     
   1e3b8:	e24dd028 	sub	sp, sp, #40	; 0x28                            <== NOT EXECUTED
  rtems_filesystem_node_types_t type;                                 
  rtems_rfs_inode_handle        inode;                                
  uint16_t                      mode;                                 
  int                           rc;                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e3bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e3c0:	ebffff46 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e3c4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1e3c8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e3cc:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   1e3d0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e3d4:	eb00656a 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   1e3d8:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e3dc:	da000004 	ble	1e3f4 <rtems_rfs_rtems_node_type+0x4c>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e3e0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e3e4:	ebffff42 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("node_type: opening inode", rc);    
   1e3e8:	eb007ac4 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e3ec:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e3f0:	ea000016 	b	1e450 <rtems_rfs_rtems_node_type+0xa8>          <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   1e3f4:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   * link is actually the normal path to a regular file, directory, device
   * etc's inode. Links to inodes can be considered "the real" one, yet they
   * are all links.                                                   
   */                                                                 
  mode = rtems_rfs_inode_get_mode (&inode);                           
  if (RTEMS_RFS_S_ISDIR (mode))                                       
   1e3f8:	e5d33002 	ldrb	r3, [r3, #2]                                 <== NOT EXECUTED
   1e3fc:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   1e400:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   1e404:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   1e408:	03a05001 	moveq	r5, #1                                      <== NOT EXECUTED
   1e40c:	0a000006 	beq	1e42c <rtems_rfs_rtems_node_type+0x84>        <== NOT EXECUTED
    type = RTEMS_FILESYSTEM_DIRECTORY;                                
  else if (RTEMS_RFS_S_ISLNK (mode))                                  
   1e410:	e3530a0a 	cmp	r3, #40960	; 0xa000                           <== NOT EXECUTED
   1e414:	03a05004 	moveq	r5, #4                                      <== NOT EXECUTED
   1e418:	0a000003 	beq	1e42c <rtems_rfs_rtems_node_type+0x84>        <== NOT EXECUTED
    type = RTEMS_FILESYSTEM_SYM_LINK;                                 
  else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))      
   1e41c:	e3530a06 	cmp	r3, #24576	; 0x6000                           <== NOT EXECUTED
   1e420:	13530a02 	cmpne	r3, #8192	; 0x2000                          <== NOT EXECUTED
   1e424:	03a05002 	moveq	r5, #2                                      <== NOT EXECUTED
   1e428:	13a05005 	movne	r5, #5                                      <== NOT EXECUTED
    type = RTEMS_FILESYSTEM_DEVICE;                                   
  else                                                                
    type = RTEMS_FILESYSTEM_MEMORY_FILE;                              
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1e42c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e430:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   1e434:	eb00652f 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   1e438:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1e43c:	da000005 	ble	1e458 <rtems_rfs_rtems_node_type+0xb0>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e440:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e444:	ebffff2a 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("node_type: closing inode", rc);    
   1e448:	eb007aac 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e44c:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
   1e450:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   1e454:	ea000001 	b	1e460 <rtems_rfs_rtems_node_type+0xb8>          <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e458:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e45c:	ebffff24 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return type;                                                        
}                                                                     
   1e460:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1e464:	e28dd028 	add	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   1e468:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

0001ed68 <rtems_rfs_rtems_readlink>: int rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc, char* buf, size_t bufsize) {
   1ed68:	e92d40f3 	push	{r0, r1, r4, r5, r6, r7, lr}                 <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
   1ed6c:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1ed70:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino           ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1ed74:	e5907000 	ldr	r7, [r0]                                      <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,  
                          char*                             buf,      
                          size_t                            bufsize)  
{                                                                     
   1ed78:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   1ed7c:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  int                     rc;                                         
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))         
    printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino); 
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1ed80:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ed84:	ebfffcd5 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);       
   1ed88:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   1ed8c:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
   1ed90:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1ed94:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1ed98:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ed9c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1eda0:	eb0063f1 	bl	37d6c <rtems_rfs_symlink_read>                 <== NOT EXECUTED
  if (rc)                                                             
   1eda4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1eda8:	0a000005 	beq	1edc4 <rtems_rfs_rtems_readlink+0x5c>         <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1edac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1edb0:	ebfffccf 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
   1edb4:	eb007851 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1edb8:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1edbc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1edc0:	ea000002 	b	1edd0 <rtems_rfs_rtems_readlink+0x68>           <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1edc4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1edc8:	ebfffcc9 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
                                                                      
  return (int) length;                                                
   1edcc:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
}                                                                     
   1edd0:	e8bd80fc 	pop	{r2, r3, r4, r5, r6, r7, pc}                  <== NOT EXECUTED
                                                                      

0001e778 <rtems_rfs_rtems_rename>: rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc, rtems_filesystem_location_info_t* old_loc, rtems_filesystem_location_info_t* new_parent_loc, const char* new_name) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
   1e778:	e591c010 	ldr	ip, [r1, #16]                                 <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
                       rtems_filesystem_location_info_t* old_loc,     
                       rtems_filesystem_location_info_t* new_parent_loc,
                       const char*                       new_name)    
{                                                                     
   1e77c:	e92d45f3 	push	{r0, r1, r4, r5, r6, r7, r8, sl, lr}         <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (old_loc); 
   1e780:	e59c4034 	ldr	r4, [ip, #52]	; 0x34                          <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
                       rtems_filesystem_location_info_t* old_loc,     
                       rtems_filesystem_location_info_t* new_parent_loc,
                       const char*                       new_name)    
{                                                                     
   1e784:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
  rtems_rfs_ino           new_parent;                                 
  rtems_rfs_ino           ino;                                        
  uint32_t                doff;                                       
  int                     rc;                                         
                                                                      
  old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);      
   1e788:	e5907000 	ldr	r7, [r0]                                      <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))           
    printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
            ino, doff, new_parent, new_name);                         
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e78c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  rtems_rfs_ino           ino;                                        
  uint32_t                doff;                                       
  int                     rc;                                         
                                                                      
  old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);      
  new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);      
   1e790:	e5928000 	ldr	r8, [r2]                                      <== NOT EXECUTED
                                                                      
  ino  = rtems_rfs_rtems_get_pathloc_ino (old_loc);                   
   1e794:	e8910060 	ldm	r1, {r5, r6}                                  <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))           
    printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
            ino, doff, new_parent, new_name);                         
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e798:	ebfffe50 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Link to the inode before unlinking so the inode is not erased when
   * unlinked.                                                        
   */                                                                 
  rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
   1e79c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   1e7a0:	eb0094d3 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1e7a4:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
   1e7a8:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   1e7ac:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
   1e7b0:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   1e7b4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e7b8:	e88d1020 	stm	sp, {r5, ip}                                  <== NOT EXECUTED
   1e7bc:	eb0066d4 	bl	38314 <rtems_rfs_link>                         <== NOT EXECUTED
  if (rc)                                                             
   1e7c0:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
   1e7c4:	0a000004 	beq	1e7dc <rtems_rfs_rtems_rename+0x64>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e7c8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e7cc:	ebfffe48 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("rename: linking", rc);             
   1e7d0:	eb0079ca 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e7d4:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   1e7d8:	ea00000c 	b	1e810 <rtems_rfs_rtems_rename+0x98>             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Unlink all inodes even directories with the dir option as false because a
   * directory may not be empty.                                      
   */                                                                 
  rc = rtems_rfs_unlink (fs, old_parent, ino, doff,                   
   1e7dc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   1e7e0:	e3a0c002 	mov	ip, #2                                        <== NOT EXECUTED
   1e7e4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1e7e8:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   1e7ec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e7f0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1e7f4:	eb006644 	bl	3810c <rtems_rfs_unlink>                       <== NOT EXECUTED
                         rtems_rfs_unlink_dir_allowed);               
  if (rc)                                                             
   1e7f8:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e7fc:	0a000005 	beq	1e818 <rtems_rfs_rtems_rename+0xa0>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e800:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e804:	ebfffe3a 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("rename: unlinking", rc);           
   1e808:	eb0079bc 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e80c:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e810:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e814:	ea000002 	b	1e824 <rtems_rfs_rtems_rename+0xac>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e818:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e81c:	ebfffe34 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e820:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e824:	e8bd85fc 	pop	{r2, r3, r4, r5, r6, r7, r8, sl, pc}          <== NOT EXECUTED
                                                                      

0001e828 <rtems_rfs_rtems_rmnod>: */ int rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc, rtems_filesystem_location_info_t* pathloc) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
   1e828:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
                       rtems_filesystem_location_info_t* pathloc)     
{                                                                     
   1e82c:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1e830:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  uint32_t               doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
   1e834:	e5915004 	ldr	r5, [r1, #4]                                  <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
                       rtems_filesystem_location_info_t* pathloc)     
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
   1e838:	e5907000 	ldr	r7, [r0]                                      <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1e83c:	e5916000 	ldr	r6, [r1]                                      <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RMNOD))            
    printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
            parent, doff, ino);                                       
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e840:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e844:	ebfffe25 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
   1e848:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   1e84c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1e850:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1e854:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1e858:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e85c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1e860:	eb006629 	bl	3810c <rtems_rfs_unlink>                       <== NOT EXECUTED
  if (rc)                                                             
   1e864:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e868:	0a000005 	beq	1e884 <rtems_rfs_rtems_rmnod+0x5c>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e86c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e870:	ebfffe1f 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("rmnod: unlinking", rc);            
   1e874:	eb0079a1 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e878:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e87c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e880:	ea000002 	b	1e890 <rtems_rfs_rtems_rmnod+0x68>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e884:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e888:	ebfffe19 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e88c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   1e890:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      <== NOT EXECUTED
                                                                      

0001f5c4 <rtems_rfs_rtems_set_handlers>: */ bool rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc, rtems_rfs_inode_handle* inode) {
   1f5c4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
   1f5c8:	e591300c 	ldr	r3, [r1, #12]                                 <== NOT EXECUTED
   1f5cc:	e5d32003 	ldrb	r2, [r3, #3]                                 <== NOT EXECUTED
   1f5d0:	e5d31002 	ldrb	r1, [r3, #2]                                 <== NOT EXECUTED
   1f5d4:	e1821401 	orr	r1, r2, r1, lsl #8                            <== NOT EXECUTED
  uint16_t mode = rtems_rfs_inode_get_mode (inode);                   
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
   1f5d8:	e2013a0f 	and	r3, r1, #61440	; 0xf000                       <== NOT EXECUTED
   1f5dc:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
bool                                                                  
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,  
                              rtems_rfs_inode_handle*           inode)
{                                                                     
  uint16_t mode = rtems_rfs_inode_get_mode (inode);                   
  loc->handlers = NULL;                                               
   1f5e0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   1f5e4:	e5802008 	str	r2, [r0, #8]                                  <== NOT EXECUTED
  if (RTEMS_RFS_S_ISDIR (mode))                                       
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
   1f5e8:	059f304c 	ldreq	r3, [pc, #76]	; 1f63c <rtems_rfs_rtems_set_handlers+0x78><== NOT EXECUTED
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,  
                              rtems_rfs_inode_handle*           inode)
{                                                                     
  uint16_t mode = rtems_rfs_inode_get_mode (inode);                   
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
   1f5ec:	0a00000b 	beq	1f620 <rtems_rfs_rtems_set_handlers+0x5c>     <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
  else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))       
   1f5f0:	e3530a02 	cmp	r3, #8192	; 0x2000                            <== NOT EXECUTED
   1f5f4:	13530a06 	cmpne	r3, #24576	; 0x6000                         <== NOT EXECUTED
   1f5f8:	13a04000 	movne	r4, #0                                      <== NOT EXECUTED
   1f5fc:	03a04001 	moveq	r4, #1                                      <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (device);                
   1f600:	059f3038 	ldreq	r3, [pc, #56]	; 1f640 <rtems_rfs_rtems_set_handlers+0x7c><== NOT EXECUTED
{                                                                     
  uint16_t mode = rtems_rfs_inode_get_mode (inode);                   
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
  else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))       
   1f604:	0a000005 	beq	1f620 <rtems_rfs_rtems_set_handlers+0x5c>     <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (device);                
  else if (RTEMS_RFS_S_ISLNK (mode))                                  
   1f608:	e3530a0a 	cmp	r3, #40960	; 0xa000                           <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
   1f60c:	059f3030 	ldreq	r3, [pc, #48]	; 1f644 <rtems_rfs_rtems_set_handlers+0x80><== NOT EXECUTED
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
  else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))       
    loc->handlers = rtems_rfs_rtems_handlers (device);                
  else if (RTEMS_RFS_S_ISLNK (mode))                                  
   1f610:	0a000002 	beq	1f620 <rtems_rfs_rtems_set_handlers+0x5c>     <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
  else if (RTEMS_RFS_S_ISREG (mode))                                  
   1f614:	e3530902 	cmp	r3, #32768	; 0x8000                           <== NOT EXECUTED
   1f618:	1a000003 	bne	1f62c <rtems_rfs_rtems_set_handlers+0x68>     <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (file);                  
   1f61c:	e59f3024 	ldr	r3, [pc, #36]	; 1f648 <rtems_rfs_rtems_set_handlers+0x84><== NOT EXECUTED
   1f620:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
   1f624:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
   1f628:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
   1f62c:	e59f0018 	ldr	r0, [pc, #24]	; 1f64c <rtems_rfs_rtems_set_handlers+0x88><== NOT EXECUTED
   1f630:	eb008790 	bl	41478 <printf>                                 <== NOT EXECUTED
   1f634:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
   1f638:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

0001e46c <rtems_rfs_rtems_shutdown>: * Shutdown the file system. */ int rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry) { rtems_rfs_file_system* fs = mt_entry->fs_info;
   1e46c:	e5903034 	ldr	r3, [r0, #52]	; 0x34                          <== NOT EXECUTED
/**                                                                   
 * Shutdown the file system.                                          
 */                                                                   
int                                                                   
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{                                                                     
   1e470:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_rfs_rtems_private* rtems;                                     
  int                      rc;                                        
                                                                      
  rtems = rtems_rfs_fs_user (fs);                                     
                                                                      
  rc = rtems_rfs_fs_close(fs);                                        
   1e474:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
{                                                                     
  rtems_rfs_file_system*   fs = mt_entry->fs_info;                    
  rtems_rfs_rtems_private* rtems;                                     
  int                      rc;                                        
                                                                      
  rtems = rtems_rfs_fs_user (fs);                                     
   1e478:	e593507c 	ldr	r5, [r3, #124]	; 0x7c                         <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_fs_close(fs);                                        
   1e47c:	eb005eb1 	bl	35f48 <rtems_rfs_fs_close>                     <== NOT EXECUTED
   1e480:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  rtems_rfs_mutex_destroy (&rtems->access);                           
   1e484:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1e488:	eb0067f8 	bl	38470 <rtems_rfs_mutex_destroy>                <== NOT EXECUTED
  free (rtems);                                                       
   1e48c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1e490:	ebffa487 	bl	76b4 <free>                                    <== NOT EXECUTED
                                                                      
  return rtems_rfs_rtems_error ("shutdown: close", rc);               
   1e494:	eb007a99 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e498:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
   1e49c:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
}                                                                     
   1e4a0:	01a00004 	moveq	r0, r4                                      <== NOT EXECUTED
   1e4a4:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
   1e4a8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

0001ead0 <rtems_rfs_rtems_stat>: */ int rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc, struct stat* buf) {
   1ead0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
   1ead4:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1ead8:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino           ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1eadc:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
 */                                                                   
                                                                      
int                                                                   
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,      
                      struct stat*                      buf)          
{                                                                     
   1eae0:	e24dd028 	sub	sp, sp, #40	; 0x28                            <== NOT EXECUTED
  int                     rc;                                         
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))             
    printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);     
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1eae4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
 */                                                                   
                                                                      
int                                                                   
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,      
                      struct stat*                      buf)          
{                                                                     
   1eae8:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  int                     rc;                                         
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))             
    printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);     
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1eaec:	ebfffd7b 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1eaf0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1eaf4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1eaf8:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   1eafc:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1eb00:	eb00639f 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   1eb04:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1eb08:	0a000004 	beq	1eb20 <rtems_rfs_rtems_stat+0x50>             <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1eb0c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1eb10:	ebfffd77 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("stat: opening inode", rc);         
   1eb14:	eb0078f9 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1eb18:	e5807000 	str	r7, [r0]                                      <== NOT EXECUTED
   1eb1c:	ea000089 	b	1ed48 <rtems_rfs_rtems_stat+0x278>              <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   1eb20:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  mode = rtems_rfs_inode_get_mode (&inode);                           
                                                                      
  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))           
   1eb24:	e5d23003 	ldrb	r3, [r2, #3]                                 <== NOT EXECUTED
   1eb28:	e5d20002 	ldrb	r0, [r2, #2]                                 <== NOT EXECUTED
   1eb2c:	e1830400 	orr	r0, r3, r0, lsl #8                            <== NOT EXECUTED
   1eb30:	e2003a0f 	and	r3, r0, #61440	; 0xf000                       <== NOT EXECUTED
   1eb34:	e3530a02 	cmp	r3, #8192	; 0x2000                            <== NOT EXECUTED
   1eb38:	13530a06 	cmpne	r3, #24576	; 0x6000                         <== NOT EXECUTED
   1eb3c:	1a000011 	bne	1eb88 <rtems_rfs_rtems_stat+0xb8>             <== NOT EXECUTED
 * @return uint32_t The block number.                                 
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block) 
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);      
   1eb40:	e282301c 	add	r3, r2, #28                                   <== NOT EXECUTED
   1eb44:	e5d38005 	ldrb	r8, [r3, #5]                                 <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
   1eb48:	e5d2101c 	ldrb	r1, [r2, #28]                                <== NOT EXECUTED
   1eb4c:	e5d3c004 	ldrb	ip, [r3, #4]                                 <== NOT EXECUTED
   1eb50:	e5d32003 	ldrb	r2, [r3, #3]                                 <== NOT EXECUTED
   1eb54:	e5d3e001 	ldrb	lr, [r3, #1]                                 <== NOT EXECUTED
   1eb58:	e5d37007 	ldrb	r7, [r3, #7]                                 <== NOT EXECUTED
   1eb5c:	e1a08808 	lsl	r8, r8, #16                                   <== NOT EXECUTED
   1eb60:	e1888c0c 	orr	r8, r8, ip, lsl #24                           <== NOT EXECUTED
   1eb64:	e1822c01 	orr	r2, r2, r1, lsl #24                           <== NOT EXECUTED
   1eb68:	e5d3c006 	ldrb	ip, [r3, #6]                                 <== NOT EXECUTED
   1eb6c:	e5d31002 	ldrb	r1, [r3, #2]                                 <== NOT EXECUTED
   1eb70:	e182280e 	orr	r2, r2, lr, lsl #16                           <== NOT EXECUTED
   1eb74:	e1883007 	orr	r3, r8, r7                                    <== NOT EXECUTED
   1eb78:	e183340c 	orr	r3, r3, ip, lsl #8                            <== NOT EXECUTED
   1eb7c:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
  {                                                                   
    buf->st_rdev =                                                    
   1eb80:	e5842018 	str	r2, [r4, #24]                                 <== NOT EXECUTED
   1eb84:	e584301c 	str	r3, [r4, #28]                                 <== NOT EXECUTED
      rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
                                   rtems_rfs_inode_get_block (&inode, 1));
  }                                                                   
                                                                      
  buf->st_dev     = rtems_rfs_fs_device (fs);                         
   1eb88:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
   1eb8c:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
  buf->st_ino     = ino;                                              
   1eb90:	e5846008 	str	r6, [r4, #8]                                  <== NOT EXECUTED
    buf->st_rdev =                                                    
      rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
                                   rtems_rfs_inode_get_block (&inode, 1));
  }                                                                   
                                                                      
  buf->st_dev     = rtems_rfs_fs_device (fs);                         
   1eb94:	e884000c 	stm	r4, {r2, r3}                                  <== NOT EXECUTED
  buf->st_ino     = ino;                                              
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
   1eb98:	eb000288 	bl	1f5c0 <rtems_rfs_rtems_mode>                   <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   1eb9c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1eba0:	e584000c 	str	r0, [r4, #12]                                 <== NOT EXECUTED
   1eba4:	e5d31000 	ldrb	r1, [r3]                                     <== NOT EXECUTED
   1eba8:	e5d32001 	ldrb	r2, [r3, #1]                                 <== NOT EXECUTED
   1ebac:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
  if (links == 0xffff)                                                
   1ebb0:	e59f11ac 	ldr	r1, [pc, #428]	; 1ed64 <rtems_rfs_rtems_stat+0x294><== NOT EXECUTED
   1ebb4:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   1ebb8:	03a02000 	moveq	r2, #0                                      <== NOT EXECUTED
  buf->st_nlink   = rtems_rfs_inode_get_links (&inode);               
   1ebbc:	e1c421b0 	strh	r2, [r4, #16]                                <== NOT EXECUTED
  buf->st_uid     = rtems_rfs_inode_get_uid (&inode);                 
   1ebc0:	e5d31006 	ldrb	r1, [r3, #6]                                 <== NOT EXECUTED
   1ebc4:	e5d32007 	ldrb	r2, [r3, #7]                                 <== NOT EXECUTED
   1ebc8:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
   1ebcc:	e1c421b2 	strh	r2, [r4, #18]                                <== NOT EXECUTED
  buf->st_gid     = rtems_rfs_inode_get_gid (&inode);                 
   1ebd0:	e5d31007 	ldrb	r1, [r3, #7]                                 <== NOT EXECUTED
   1ebd4:	e5d30004 	ldrb	r0, [r3, #4]                                 <== NOT EXECUTED
   1ebd8:	e5d32005 	ldrb	r2, [r3, #5]                                 <== NOT EXECUTED
   1ebdc:	e1813c00 	orr	r3, r1, r0, lsl #24                           <== NOT EXECUTED
   1ebe0:	e1833802 	orr	r3, r3, r2, lsl #16                           <== NOT EXECUTED
   1ebe4:	e1a03823 	lsr	r3, r3, #16                                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Need to check is the ino is an open file. If so we take the values from
   * the open file rather than the inode.                             
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, ino);                       
   1ebe8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
  buf->st_dev     = rtems_rfs_fs_device (fs);                         
  buf->st_ino     = ino;                                              
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
  buf->st_nlink   = rtems_rfs_inode_get_links (&inode);               
  buf->st_uid     = rtems_rfs_inode_get_uid (&inode);                 
  buf->st_gid     = rtems_rfs_inode_get_gid (&inode);                 
   1ebec:	e1c431b4 	strh	r3, [r4, #20]                                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Need to check is the ino is an open file. If so we take the values from
   * the open file rather than the inode.                             
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, ino);                       
   1ebf0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ebf4:	eb005a23 	bl	35488 <rtems_rfs_file_get_shared>              <== NOT EXECUTED
                                                                      
  if (shared)                                                         
   1ebf8:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   1ebfc:	e594000c 	ldr	r0, [r4, #12]                                 <== NOT EXECUTED
   1ec00:	0a000012 	beq	1ec50 <rtems_rfs_rtems_stat+0x180>            <== NOT EXECUTED
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
   1ec04:	e591308c 	ldr	r3, [r1, #140]	; 0x8c                         <== NOT EXECUTED
   1ec08:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
   1ec0c:	e5913090 	ldr	r3, [r1, #144]	; 0x90                         <== NOT EXECUTED
   1ec10:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
   1ec14:	e5913094 	ldr	r3, [r1, #148]	; 0x94                         <== NOT EXECUTED
   1ec18:	e5843038 	str	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
    buf->st_blocks  = rtems_rfs_file_shared_get_block_count (shared); 
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
   1ec1c:	e2000a0f 	and	r0, r0, #61440	; 0xf000                       <== NOT EXECUTED
  if (shared)                                                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
    buf->st_blocks  = rtems_rfs_file_shared_get_block_count (shared); 
   1ec20:	e5913084 	ldr	r3, [r1, #132]	; 0x84                         <== NOT EXECUTED
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
   1ec24:	e3500a0a 	cmp	r0, #40960	; 0xa000                           <== NOT EXECUTED
  if (shared)                                                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
    buf->st_blocks  = rtems_rfs_file_shared_get_block_count (shared); 
   1ec28:	e5843044 	str	r3, [r4, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
      buf->st_size = rtems_rfs_file_shared_get_block_offset (shared); 
   1ec2c:	01d138b8 	ldrheq	r3, [r1, #136]	; 0x88                      <== NOT EXECUTED
   1ec30:	05843020 	streq	r3, [r4, #32]                               <== NOT EXECUTED
   1ec34:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   1ec38:	05843024 	streq	r3, [r4, #36]	; 0x24                        <== NOT EXECUTED
   1ec3c:	0a000036 	beq	1ed1c <rtems_rfs_rtems_stat+0x24c>            <== NOT EXECUTED
 */                                                                   
static inline rtems_rfs_pos                                           
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,            
                                rtems_rfs_file_shared* shared)        
{                                                                     
  return rtems_rfs_block_get_size (fs, &shared->size);                
   1ec40:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ec44:	e2811084 	add	r1, r1, #132	; 0x84                           <== NOT EXECUTED
   1ec48:	eb00526b 	bl	335fc <rtems_rfs_block_get_size>               <== NOT EXECUTED
   1ec4c:	ea000030 	b	1ed14 <rtems_rfs_rtems_stat+0x244>              <== NOT EXECUTED
 * @return rtems_rfs_time The atime.                                  
 */                                                                   
static inline rtems_rfs_time                                          
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)            
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->atime);                   
   1ec50:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1ec54:	e2832010 	add	r2, r3, #16                                   <== NOT EXECUTED
    else                                                              
      buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);     
  }                                                                   
  else                                                                
  {                                                                   
    buf->st_atime   = rtems_rfs_inode_get_atime (&inode);             
   1ec58:	e5d2c003 	ldrb	ip, [r2, #3]                                 <== NOT EXECUTED
   1ec5c:	e5d3e010 	ldrb	lr, [r3, #16]                                <== NOT EXECUTED
   1ec60:	e5d26001 	ldrb	r6, [r2, #1]                                 <== NOT EXECUTED
   1ec64:	e18cec0e 	orr	lr, ip, lr, lsl #24                           <== NOT EXECUTED
   1ec68:	e5d2c002 	ldrb	ip, [r2, #2]                                 <== NOT EXECUTED
   1ec6c:	e18e2806 	orr	r2, lr, r6, lsl #16                           <== NOT EXECUTED
   1ec70:	e182240c 	orr	r2, r2, ip, lsl #8                            <== NOT EXECUTED
   1ec74:	e5842028 	str	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
 * @return rtems_rfs_time The mtime.                                  
 */                                                                   
static inline rtems_rfs_time                                          
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)            
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->mtime);                   
   1ec78:	e2832014 	add	r2, r3, #20                                   <== NOT EXECUTED
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
   1ec7c:	e5d2c003 	ldrb	ip, [r2, #3]                                 <== NOT EXECUTED
   1ec80:	e5d3e014 	ldrb	lr, [r3, #20]                                <== NOT EXECUTED
   1ec84:	e5d26001 	ldrb	r6, [r2, #1]                                 <== NOT EXECUTED
   1ec88:	e18cec0e 	orr	lr, ip, lr, lsl #24                           <== NOT EXECUTED
   1ec8c:	e5d2c002 	ldrb	ip, [r2, #2]                                 <== NOT EXECUTED
   1ec90:	e18e2806 	orr	r2, lr, r6, lsl #16                           <== NOT EXECUTED
   1ec94:	e182240c 	orr	r2, r2, ip, lsl #8                            <== NOT EXECUTED
   1ec98:	e5842030 	str	r2, [r4, #48]	; 0x30                          <== NOT EXECUTED
 * @return rtems_rfs_time The ctime.                                  
 */                                                                   
static inline rtems_rfs_time                                          
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)            
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->ctime);                   
   1ec9c:	e2832018 	add	r2, r3, #24                                   <== NOT EXECUTED
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
   1eca0:	e5d2c003 	ldrb	ip, [r2, #3]                                 <== NOT EXECUTED
   1eca4:	e5d3e018 	ldrb	lr, [r3, #24]                                <== NOT EXECUTED
   1eca8:	e5d26001 	ldrb	r6, [r2, #1]                                 <== NOT EXECUTED
   1ecac:	e18cec0e 	orr	lr, ip, lr, lsl #24                           <== NOT EXECUTED
   1ecb0:	e5d2c002 	ldrb	ip, [r2, #2]                                 <== NOT EXECUTED
   1ecb4:	e18e2806 	orr	r2, lr, r6, lsl #16                           <== NOT EXECUTED
   1ecb8:	e182240c 	orr	r2, r2, ip, lsl #8                            <== NOT EXECUTED
   1ecbc:	e5842038 	str	r2, [r4, #56]	; 0x38                          <== NOT EXECUTED
 * @return uint32_t The block count.                                  
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)      
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->block_count);             
   1ecc0:	e283200c 	add	r2, r3, #12                                   <== NOT EXECUTED
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
   1ecc4:	e5d2c003 	ldrb	ip, [r2, #3]                                 <== NOT EXECUTED
   1ecc8:	e5d3e00c 	ldrb	lr, [r3, #12]                                <== NOT EXECUTED
   1eccc:	e5d26001 	ldrb	r6, [r2, #1]                                 <== NOT EXECUTED
   1ecd0:	e18cec0e 	orr	lr, ip, lr, lsl #24                           <== NOT EXECUTED
   1ecd4:	e5d2c002 	ldrb	ip, [r2, #2]                                 <== NOT EXECUTED
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
   1ecd8:	e2000a0f 	and	r0, r0, #61440	; 0xf000                       <== NOT EXECUTED
  else                                                                
  {                                                                   
    buf->st_atime   = rtems_rfs_inode_get_atime (&inode);             
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
   1ecdc:	e18e2806 	orr	r2, lr, r6, lsl #16                           <== NOT EXECUTED
   1ece0:	e182240c 	orr	r2, r2, ip, lsl #8                            <== NOT EXECUTED
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
   1ece4:	e3500a0a 	cmp	r0, #40960	; 0xa000                           <== NOT EXECUTED
  else                                                                
  {                                                                   
    buf->st_atime   = rtems_rfs_inode_get_atime (&inode);             
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
   1ece8:	e5842044 	str	r2, [r4, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
   1ecec:	1a000005 	bne	1ed08 <rtems_rfs_rtems_stat+0x238>            <== NOT EXECUTED
      buf->st_size = rtems_rfs_inode_get_block_offset (&inode);       
   1ecf0:	e5d3200b 	ldrb	r2, [r3, #11]                                <== NOT EXECUTED
   1ecf4:	e5d3300a 	ldrb	r3, [r3, #10]                                <== NOT EXECUTED
   1ecf8:	e1823403 	orr	r3, r2, r3, lsl #8                            <== NOT EXECUTED
   1ecfc:	e5843020 	str	r3, [r4, #32]                                 <== NOT EXECUTED
   1ed00:	e5841024 	str	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
   1ed04:	ea000004 	b	1ed1c <rtems_rfs_rtems_stat+0x24c>              <== NOT EXECUTED
    else                                                              
      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);           
   1ed08:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ed0c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   1ed10:	eb006235 	bl	375ec <rtems_rfs_inode_get_size>               <== NOT EXECUTED
   1ed14:	e5840020 	str	r0, [r4, #32]                                 <== NOT EXECUTED
   1ed18:	e5841024 	str	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
  }                                                                   
                                                                      
  buf->st_blksize = rtems_rfs_fs_block_size (fs);                     
   1ed1c:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1ed20:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
      buf->st_size = rtems_rfs_inode_get_block_offset (&inode);       
    else                                                              
      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);           
  }                                                                   
                                                                      
  buf->st_blksize = rtems_rfs_fs_block_size (fs);                     
   1ed24:	e5843040 	str	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1ed28:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   1ed2c:	eb0062f1 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   1ed30:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
   1ed34:	da000005 	ble	1ed50 <rtems_rfs_rtems_stat+0x280>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1ed38:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ed3c:	ebfffcec 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("stat: closing inode", rc);         
   1ed40:	eb00786e 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1ed44:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
   1ed48:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1ed4c:	ea000002 	b	1ed5c <rtems_rfs_rtems_stat+0x28c>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1ed50:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ed54:	ebfffce6 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1ed58:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   1ed5c:	e28dd028 	add	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   1ed60:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0001e668 <rtems_rfs_rtems_statvfs>: * @return int */ int rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc, struct statvfs* sb) {
   1e668:	e92d4033 	push	{r0, r1, r4, r5, lr}                         <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1e66c:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1e670:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          <== NOT EXECUTED
 * @return int                                                        
 */                                                                   
int                                                                   
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,   
                         struct statvfs*                   sb)        
{                                                                     
   1e674:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
   1e678:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   1e67c:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
   1e680:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1e684:	eb0062a8 	bl	3712c <rtems_rfs_group_usage>                  <== NOT EXECUTED
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
   1e688:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
   1e68c:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
   1e690:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
   1e694:	e5932024 	ldr	r2, [r3, #36]	; 0x24                          <== NOT EXECUTED
   1e698:	e5842004 	str	r2, [r4, #4]                                  <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
   1e69c:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
   1e6a0:	e5951010 	ldr	r1, [r5, #16]                                 <== NOT EXECUTED
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
   1e6a4:	e593c01c 	ldr	ip, [r3, #28]                                 <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
  sb->f_favail  = sb->f_ffree;                                        
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
   1e6a8:	e59f304c 	ldr	r3, [pc, #76]	; 1e6fc <rtems_rfs_rtems_statvfs+0x94><== NOT EXECUTED
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
   1e6ac:	e0622001 	rsb	r2, r2, r1                                    <== NOT EXECUTED
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
   1e6b0:	e5950004 	ldr	r0, [r5, #4]                                  <== NOT EXECUTED
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
  sb->f_favail  = sb->f_ffree;                                        
   1e6b4:	e5842028 	str	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
   1e6b8:	e584302c 	str	r3, [r4, #44]	; 0x2c                          <== NOT EXECUTED
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
   1e6bc:	e5841020 	str	r1, [r4, #32]                                 <== NOT EXECUTED
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
   1e6c0:	e5842024 	str	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
  sb->f_favail  = sb->f_ffree;                                        
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
   1e6c4:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   1e6c8:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
   1e6cc:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
  sb->f_favail  = sb->f_ffree;                                        
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
  sb->f_namemax = rtems_rfs_fs_max_name (fs);                         
   1e6d0:	e5952018 	ldr	r2, [r5, #24]                                 <== NOT EXECUTED
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
   1e6d4:	e0633000 	rsb	r3, r3, r0                                    <== NOT EXECUTED
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
   1e6d8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
  sb->f_favail  = sb->f_ffree;                                        
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
  sb->f_namemax = rtems_rfs_fs_max_name (fs);                         
   1e6dc:	e5842034 	str	r2, [r4, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
   1e6e0:	e584c008 	str	ip, [r4, #8]                                  <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
  sb->f_bavail  = sb->f_bfree;                                        
   1e6e4:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
   1e6e8:	e584000c 	str	r0, [r4, #12]                                 <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
   1e6ec:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
   1e6f0:	e5840014 	str	r0, [r4, #20]                                 <== NOT EXECUTED
  sb->f_bavail  = sb->f_bfree;                                        
   1e6f4:	e584001c 	str	r0, [r4, #28]                                 <== NOT EXECUTED
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
  sb->f_namemax = rtems_rfs_fs_max_name (fs);                         
                                                                      
  return 0;                                                           
}                                                                     
   1e6f8:	e8bd803c 	pop	{r2, r3, r4, r5, pc}                          <== NOT EXECUTED
                                                                      

0001edd4 <rtems_rfs_rtems_symlink>: int rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc, const char* link_name, const char* node_name) {
   1edd4:	e92d41ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}     <== NOT EXECUTED
   1edd8:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
   1eddc:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
   1ede0:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
                         const char*                       link_name, 
                         const char*                       node_name) 
{                                                                     
   1ede4:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1ede8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
                         const char*                       link_name, 
                         const char*                       node_name) 
{                                                                     
   1edec:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
   1edf0:	e5935000 	ldr	r5, [r3]                                      <== NOT EXECUTED
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1edf4:	ebfffcb9 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),          
   1edf8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1edfc:	eb00933c 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   1ee00:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
                          link_name, strlen (link_name),              
   1ee04:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1ee08:	eb009339 	bl	43af4 <strlen>                                 <== NOT EXECUTED
  gid = 0;                                                            
#endif                                                                
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),          
   1ee0c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1ee10:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   1ee14:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1ee18:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   1ee1c:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   1ee20:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ee24:	e58d500c 	str	r5, [sp, #12]                                 <== NOT EXECUTED
   1ee28:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   1ee2c:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
   1ee30:	eb006435 	bl	37f0c <rtems_rfs_symlink>                      <== NOT EXECUTED
                          link_name, strlen (link_name),              
                          uid, gid, parent);                          
  if (rc)                                                             
   1ee34:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1ee38:	0a000005 	beq	1ee54 <rtems_rfs_rtems_symlink+0x80>          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1ee3c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ee40:	ebfffcab 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("symlink: linking", rc);            
   1ee44:	eb00782d 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1ee48:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1ee4c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1ee50:	ea000002 	b	1ee60 <rtems_rfs_rtems_symlink+0x8c>            <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1ee54:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1ee58:	ebfffca5 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1ee5c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1ee60:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   1ee64:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

0001e894 <rtems_rfs_rtems_unlink>: int rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc, rtems_filesystem_location_info_t* loc) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
   1e894:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
 */                                                                   
                                                                      
int                                                                   
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc, 
                        rtems_filesystem_location_info_t* loc)        
{                                                                     
   1e898:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
   1e89c:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (loc); 
  uint32_t               doff = rtems_rfs_rtems_get_pathloc_doff (loc);
   1e8a0:	e5915004 	ldr	r5, [r1, #4]                                  <== NOT EXECUTED
int                                                                   
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc, 
                        rtems_filesystem_location_info_t* loc)        
{                                                                     
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
  rtems_rfs_ino          parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
   1e8a4:	e5907000 	ldr	r7, [r0]                                      <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (loc); 
   1e8a8:	e5916000 	ldr	r6, [r1]                                      <== NOT EXECUTED
  uint32_t               doff = rtems_rfs_rtems_get_pathloc_doff (loc);
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e8ac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e8b0:	ebfffe0a 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))           
    printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
           parent, doff, ino);                                        
                                                                      
  rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
   1e8b4:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   1e8b8:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
   1e8bc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1e8c0:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1e8c4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e8c8:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1e8cc:	eb00660e 	bl	3810c <rtems_rfs_unlink>                       <== NOT EXECUTED
  if (rc)                                                             
   1e8d0:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e8d4:	0a000005 	beq	1e8f0 <rtems_rfs_rtems_unlink+0x5c>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e8d8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e8dc:	ebfffe04 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("unlink: unlink inode", rc);        
   1e8e0:	eb007986 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e8e4:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e8e8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e8ec:	ea000002 	b	1e8fc <rtems_rfs_rtems_unlink+0x68>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e8f0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e8f4:	ebfffdfe 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e8f8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e8fc:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      <== NOT EXECUTED
                                                                      

0001e0f4 <rtems_rfs_rtems_unlock>: /** * Unlock the RFS file system. */ static inline void rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs) {
   1e0f4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
   1e0f8:	e590407c 	ldr	r4, [r0, #124]	; 0x7c                         <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
   1e0fc:	eb0058dd 	bl	34478 <rtems_rfs_buffers_release>              <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
   1e100:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
  rtems_rfs_mutex_unlock (&rtems->access);                            
}                                                                     
   1e104:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
   1e108:	eaffb632 	b	b9d8 <rtems_semaphore_release>                  <== NOT EXECUTED
                                                                      

0001e2b0 <rtems_rfs_rtems_utime>: int rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc, time_t atime, time_t mtime) {
   1e2b0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
   1e2b4:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
   1e2b8:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   1e2bc:	e5908000 	ldr	r8, [r0]                                      <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,      
                      time_t                            atime,        
                      time_t                            mtime)        
{                                                                     
   1e2c0:	e24dd028 	sub	sp, sp, #40	; 0x28                            <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e2c4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
int                                                                   
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,      
                      time_t                            atime,        
                      time_t                            mtime)        
{                                                                     
   1e2c8:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   1e2cc:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
   1e2d0:	ebffff82 	bl	1e0e0 <rtems_rfs_rtems_lock>                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e2d4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
   1e2d8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e2dc:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   1e2e0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e2e4:	eb0065a6 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   1e2e8:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   1e2ec:	e1a0700d 	mov	r7, sp                                        <== NOT EXECUTED
  if (rc)                                                             
   1e2f0:	0a000004 	beq	1e308 <rtems_rfs_rtems_utime+0x58>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e2f4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e2f8:	ebffff7d 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("utime: read inode", rc);           
   1e2fc:	eb007aff 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e300:	e5808000 	str	r8, [r0]                                      <== NOT EXECUTED
   1e304:	ea000020 	b	1e38c <rtems_rfs_rtems_utime+0xdc>              <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          atime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->atime, atime);                  
   1e308:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e30c:	e1a02c26 	lsr	r2, r6, #24                                   <== NOT EXECUTED
   1e310:	e5c32010 	strb	r2, [r3, #16]                                <== NOT EXECUTED
   1e314:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e318:	e1a02826 	lsr	r2, r6, #16                                   <== NOT EXECUTED
   1e31c:	e5c32011 	strb	r2, [r3, #17]                                <== NOT EXECUTED
   1e320:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e324:	e1a02426 	lsr	r2, r6, #8                                    <== NOT EXECUTED
   1e328:	e5c32012 	strb	r2, [r3, #18]                                <== NOT EXECUTED
   1e32c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e330:	e5c36013 	strb	r6, [r3, #19]                                <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,            
                           rtems_rfs_time          mtime)             
{                                                                     
  rtems_rfs_write_u32 (&handle->node->mtime, mtime);                  
   1e334:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e338:	e1a02c25 	lsr	r2, r5, #24                                   <== NOT EXECUTED
   1e33c:	e5c32014 	strb	r2, [r3, #20]                                <== NOT EXECUTED
   1e340:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e344:	e1a02825 	lsr	r2, r5, #16                                   <== NOT EXECUTED
   1e348:	e5c32015 	strb	r2, [r3, #21]                                <== NOT EXECUTED
   1e34c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   1e350:	e1a02425 	lsr	r2, r5, #8                                    <== NOT EXECUTED
   1e354:	e5c32016 	strb	r2, [r3, #22]                                <== NOT EXECUTED
   1e358:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_inode_set_atime (&inode, atime);                          
  rtems_rfs_inode_set_mtime (&inode, mtime);                          
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   1e35c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   1e360:	e5c35017 	strb	r5, [r3, #23]                                <== NOT EXECUTED
   1e364:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   1e368:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1e36c:	e5cd3010 	strb	r3, [sp, #16]                                <== NOT EXECUTED
   1e370:	eb006560 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc)                                                             
   1e374:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   1e378:	0a000005 	beq	1e394 <rtems_rfs_rtems_utime+0xe4>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
   1e37c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e380:	ebffff5b 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
    return rtems_rfs_rtems_error ("utime: closing inode", rc);        
   1e384:	eb007add 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1e388:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
   1e38c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   1e390:	ea000002 	b	1e3a0 <rtems_rfs_rtems_utime+0xf0>              <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
   1e394:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1e398:	ebffff55 	bl	1e0f4 <rtems_rfs_rtems_unlock>                 <== NOT EXECUTED
   1e39c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1e3a0:	e28dd028 	add	sp, sp, #40	; 0x28                            <== NOT EXECUTED
   1e3a4:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00036460 <rtems_rfs_rup_quotient>: * "quotient = dividend / divisor" */ int rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor) { if (dividend == 0)
   36460:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
 * Return a rounded up integer quotient given a dividend and divisor. That is:
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
   36464:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  if (dividend == 0)                                                  
   36468:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
   3646c:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                <== NOT EXECUTED
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
   36470:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
   36474:	eb007a5f 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   36478:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
}                                                                     
   3647c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

000200f4 <rtems_rfs_shell_block>: uint8_t* data; bool state; int b; int rc; if (argc <= 1)
   200f4:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{                                                                     
   200f8:	e92d41ff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}     <== NOT EXECUTED
   200fc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  uint8_t*                data;                                       
  bool                    state;                                      
  int                     b;                                          
  int                     rc;                                         
                                                                      
  if (argc <= 1)                                                      
   20100:	ca000002 	bgt	20110 <rtems_rfs_shell_block+0x1c>            <== NOT EXECUTED
  {                                                                   
    printf ("error: no block number provided\n");                     
   20104:	e59f018c 	ldr	r0, [pc, #396]	; 20298 <rtems_rfs_shell_block+0x1a4><== NOT EXECUTED
   20108:	eb00857f 	bl	4170c <puts>                                   <== NOT EXECUTED
   2010c:	ea00003e 	b	2020c <rtems_rfs_shell_block+0x118>             <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  block = strtoul (argv[1], 0, 0);                                    
   20110:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   20114:	e5920004 	ldr	r0, [r2, #4]                                  <== NOT EXECUTED
   20118:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   2011c:	eb009390 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   20120:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   20124:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   20128:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   2012c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   20130:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   20134:	ebffade1 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);        
   20138:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   2013c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   20140:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   20144:	e28d300f 	add	r3, sp, #15                                   <== NOT EXECUTED
   20148:	eb005c1c 	bl	371c0 <rtems_rfs_group_bitmap_test>            <== NOT EXECUTED
  if (rc > 0)                                                         
   2014c:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
   20150:	da000008 	ble	20178 <rtems_rfs_shell_block+0x84>            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_shell_unlock_rfs (fs);                                  
   20154:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20158:	ebfffdcb 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
    printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
   2015c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   20160:	eb008cd7 	bl	434c4 <strerror>                               <== NOT EXECUTED
   20164:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   20168:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   2016c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   20170:	e59f0124 	ldr	r0, [pc, #292]	; 2029c <rtems_rfs_shell_block+0x1a8><== NOT EXECUTED
   20174:	ea000023 	b	20208 <rtems_rfs_shell_block+0x114>             <== NOT EXECUTED
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
   20178:	e5dd100f 	ldrb	r1, [sp, #15]                                <== NOT EXECUTED
   2017c:	e59f311c 	ldr	r3, [pc, #284]	; 202a0 <rtems_rfs_shell_block+0x1ac><== NOT EXECUTED
   20180:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   20184:	e59f2118 	ldr	r2, [pc, #280]	; 202a4 <rtems_rfs_shell_block+0x1b0><== NOT EXECUTED
   20188:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   2018c:	01a02003 	moveq	r2, r3                                      <== NOT EXECUTED
   20190:	e59f0110 	ldr	r0, [pc, #272]	; 202a8 <rtems_rfs_shell_block+0x1b4><== NOT EXECUTED
   20194:	eb0084b7 	bl	41478 <printf>                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   20198:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);    
   2019c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   201a0:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   201a4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   201a8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   201ac:	e5cd5000 	strb	r5, [sp]                                     <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   201b0:	e58d5004 	str	r5, [sp, #4]                                  <== NOT EXECUTED
  handle->buffer = NULL;                                              
   201b4:	e58d5008 	str	r5, [sp, #8]                                  <== NOT EXECUTED
   201b8:	eb005148 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
  if (rc > 0)                                                         
   201bc:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
    printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  for (b = 0, data = rtems_rfs_buffer_data (&buffer);                 
   201c0:	d59d3008 	ldrle	r3, [sp, #8]                                <== NOT EXECUTED
    printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);    
   201c4:	e1a0700d 	mov	r7, sp                                        <== NOT EXECUTED
    printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  for (b = 0, data = rtems_rfs_buffer_data (&buffer);                 
   201c8:	d5936020 	ldrle	r6, [r3, #32]                               <== NOT EXECUTED
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);    
  if (rc > 0)                                                         
   201cc:	da000020 	ble	20254 <rtems_rfs_shell_block+0x160>           <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   201d0:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   201d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   201d8:	eb0050f7 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &buffer);                      
    rtems_rfs_shell_unlock_rfs (fs);                                  
   201dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   201e0:	e58d5008 	str	r5, [sp, #8]                                  <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   201e4:	e5cd5000 	strb	r5, [sp]                                     <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   201e8:	e58d5004 	str	r5, [sp, #4]                                  <== NOT EXECUTED
   201ec:	ebfffda6 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
    printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
   201f0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   201f4:	eb008cb2 	bl	434c4 <strerror>                               <== NOT EXECUTED
   201f8:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   201fc:	e59f00a8 	ldr	r0, [pc, #168]	; 202ac <rtems_rfs_shell_block+0x1b8><== NOT EXECUTED
   20200:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   20204:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   20208:	eb00849a 	bl	41478 <printf>                                 <== NOT EXECUTED
   2020c:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
            block, rc, strerror (rc));                                
    return 1;                                                         
   20210:	ea00001e 	b	20290 <rtems_rfs_shell_block+0x19c>             <== NOT EXECUTED
  for (b = 0, data = rtems_rfs_buffer_data (&buffer);                 
       b < rtems_rfs_fs_block_size (fs);                              
       b++, data++)                                                   
  {                                                                   
    int mod = b % 16;                                                 
    if (mod == 0)                                                     
   20214:	e215300f 	ands	r3, r5, #15                                  <== NOT EXECUTED
   20218:	1a000006 	bne	20238 <rtems_rfs_shell_block+0x144>           <== NOT EXECUTED
    {                                                                 
      if (b)                                                          
   2021c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
        printf ("\n");                                                
   20220:	13a0000a 	movne	r0, #10                                     <== NOT EXECUTED
   20224:	1b008508 	blne	4164c <putchar>                              <== NOT EXECUTED
      printf ("%04x ", b);                                            
   20228:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   2022c:	e59f007c 	ldr	r0, [pc, #124]	; 202b0 <rtems_rfs_shell_block+0x1bc><== NOT EXECUTED
   20230:	eb008490 	bl	41478 <printf>                                 <== NOT EXECUTED
   20234:	ea000002 	b	20244 <rtems_rfs_shell_block+0x150>             <== NOT EXECUTED
    }                                                                 
    if (mod == 8)                                                     
   20238:	e3530008 	cmp	r3, #8                                        <== NOT EXECUTED
      printf (" ");                                                   
   2023c:	03a00020 	moveq	r0, #32                                     <== NOT EXECUTED
   20240:	0b008501 	bleq	4164c <putchar>                              <== NOT EXECUTED
    printf ("%02x ", *data);                                          
   20244:	e7d61005 	ldrb	r1, [r6, r5]                                 <== NOT EXECUTED
   20248:	e59f0064 	ldr	r0, [pc, #100]	; 202b4 <rtems_rfs_shell_block+0x1c0><== NOT EXECUTED
   2024c:	eb008489 	bl	41478 <printf>                                 <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  for (b = 0, data = rtems_rfs_buffer_data (&buffer);                 
       b < rtems_rfs_fs_block_size (fs);                              
       b++, data++)                                                   
   20250:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  for (b = 0, data = rtems_rfs_buffer_data (&buffer);                 
       b < rtems_rfs_fs_block_size (fs);                              
   20254:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
   20258:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   2025c:	3affffec 	bcc	20214 <rtems_rfs_shell_block+0x120>           <== NOT EXECUTED
    if (mod == 8)                                                     
      printf (" ");                                                   
    printf ("%02x ", *data);                                          
  }                                                                   
                                                                      
  printf ("\n");                                                      
   20260:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
   20264:	eb0084f8 	bl	4164c <putchar>                                <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   20268:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   2026c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   20270:	eb0050d1 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
    printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rtems_rfs_shell_unlock_rfs (fs);                                    
   20274:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  handle->dirty = false;                                              
   20278:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   2027c:	e5cd4000 	strb	r4, [sp]                                     <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   20280:	e58d4004 	str	r4, [sp, #4]                                  <== NOT EXECUTED
  handle->buffer = NULL;                                              
   20284:	e58d4008 	str	r4, [sp, #8]                                  <== NOT EXECUTED
   20288:	ebfffd7f 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
   2028c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   20290:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   20294:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

000202b8 <rtems_rfs_shell_data>: return rc; } static int rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[]) {
   202b8:	e92d40f3 	push	{r0, r1, r4, r5, r6, r7, lr}                 <== NOT EXECUTED
   202bc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  size_t blocks;                                                      
  size_t inodes;                                                      
  int    bpcent;                                                      
  int    ipcent;                                                      
                                                                      
  printf ("RFS Filesystem Data\n");                                   
   202c0:	e59f01a8 	ldr	r0, [pc, #424]	; 20470 <rtems_rfs_shell_data+0x1b8><== NOT EXECUTED
   202c4:	eb008510 	bl	4170c <puts>                                   <== NOT EXECUTED
  printf ("             flags: %08" PRIx32 "\n", fs->flags);          
   202c8:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
   202cc:	e59f01a0 	ldr	r0, [pc, #416]	; 20474 <rtems_rfs_shell_data+0x1bc><== NOT EXECUTED
   202d0:	eb008468 	bl	41478 <printf>                                 <== NOT EXECUTED
#if 0                                                                 
  printf ("            device: %08lx\n",         rtems_rfs_fs_device (fs));
#endif                                                                
  printf ("            blocks: %zu\n",           rtems_rfs_fs_blocks (fs));
   202d4:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
   202d8:	e59f0198 	ldr	r0, [pc, #408]	; 20478 <rtems_rfs_shell_data+0x1c0><== NOT EXECUTED
   202dc:	eb008465 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("        block size: %zu\n",           rtems_rfs_fs_block_size (fs));
   202e0:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
   202e4:	e59f0190 	ldr	r0, [pc, #400]	; 2047c <rtems_rfs_shell_data+0x1c4><== NOT EXECUTED
   202e8:	eb008462 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("              size: %" PRIu64 "\n",   rtems_rfs_fs_size (fs));
   202ec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   202f0:	eb005705 	bl	35f0c <rtems_rfs_fs_size>                      <== NOT EXECUTED
   202f4:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   202f8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   202fc:	e59f017c 	ldr	r0, [pc, #380]	; 20480 <rtems_rfs_shell_data+0x1c8><== NOT EXECUTED
   20300:	eb00845c 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("  media block size: %" PRIu32 "\n",   rtems_rfs_fs_media_block_size (fs));
   20304:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
   20308:	e59f0174 	ldr	r0, [pc, #372]	; 20484 <rtems_rfs_shell_data+0x1cc><== NOT EXECUTED
   2030c:	e5931024 	ldr	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
   20310:	eb008458 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("        media size: %" PRIu64 "\n",   rtems_rfs_fs_media_size (fs));
   20314:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20318:	eb005702 	bl	35f28 <rtems_rfs_fs_media_size>                <== NOT EXECUTED
   2031c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   20320:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   20324:	e59f015c 	ldr	r0, [pc, #348]	; 20488 <rtems_rfs_shell_data+0x1d0><== NOT EXECUTED
   20328:	eb008452 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("            inodes: %" PRIu32 "\n",   rtems_rfs_fs_inodes (fs));
   2032c:	e5941010 	ldr	r1, [r4, #16]                                 <== NOT EXECUTED
   20330:	e59f0154 	ldr	r0, [pc, #340]	; 2048c <rtems_rfs_shell_data+0x1d4><== NOT EXECUTED
   20334:	eb00844f 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("        bad blocks: %" PRIu32 "\n",   fs->bad_blocks);     
   20338:	e5941014 	ldr	r1, [r4, #20]                                 <== NOT EXECUTED
   2033c:	e59f014c 	ldr	r0, [pc, #332]	; 20490 <rtems_rfs_shell_data+0x1d8><== NOT EXECUTED
   20340:	eb00844c 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("  max. name length: %" PRIu32 "\n",   rtems_rfs_fs_max_name (fs));
   20344:	e5941018 	ldr	r1, [r4, #24]                                 <== NOT EXECUTED
   20348:	e59f0144 	ldr	r0, [pc, #324]	; 20494 <rtems_rfs_shell_data+0x1dc><== NOT EXECUTED
   2034c:	eb008449 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("            groups: %d\n",            fs->group_count);    
   20350:	e5941020 	ldr	r1, [r4, #32]                                 <== NOT EXECUTED
   20354:	e59f013c 	ldr	r0, [pc, #316]	; 20498 <rtems_rfs_shell_data+0x1e0><== NOT EXECUTED
   20358:	eb008446 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("      group blocks: %zd\n",           fs->group_blocks);   
   2035c:	e5941024 	ldr	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
   20360:	e59f0134 	ldr	r0, [pc, #308]	; 2049c <rtems_rfs_shell_data+0x1e4><== NOT EXECUTED
   20364:	eb008443 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("      group inodes: %zd\n",           fs->group_inodes);   
   20368:	e5941028 	ldr	r1, [r4, #40]	; 0x28                          <== NOT EXECUTED
   2036c:	e59f012c 	ldr	r0, [pc, #300]	; 204a0 <rtems_rfs_shell_data+0x1e8><== NOT EXECUTED
   20370:	eb008440 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("  inodes per block: %zd\n",           fs->inodes_per_block);
   20374:	e594102c 	ldr	r1, [r4, #44]	; 0x2c                          <== NOT EXECUTED
   20378:	e59f0124 	ldr	r0, [pc, #292]	; 204a4 <rtems_rfs_shell_data+0x1ec><== NOT EXECUTED
   2037c:	eb00843d 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("  blocks per block: %zd\n",           fs->blocks_per_block);
   20380:	e5941030 	ldr	r1, [r4, #48]	; 0x30                          <== NOT EXECUTED
   20384:	e59f011c 	ldr	r0, [pc, #284]	; 204a8 <rtems_rfs_shell_data+0x1f0><== NOT EXECUTED
   20388:	eb00843a 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("     singly blocks: %zd\n",           fs->block_map_singly_blocks);
   2038c:	e5941034 	ldr	r1, [r4, #52]	; 0x34                          <== NOT EXECUTED
   20390:	e59f0114 	ldr	r0, [pc, #276]	; 204ac <rtems_rfs_shell_data+0x1f4><== NOT EXECUTED
   20394:	eb008437 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("    doublly blocks: %zd\n",           fs->block_map_doubly_blocks);
   20398:	e5941038 	ldr	r1, [r4, #56]	; 0x38                          <== NOT EXECUTED
   2039c:	e59f010c 	ldr	r0, [pc, #268]	; 204b0 <rtems_rfs_shell_data+0x1f8><== NOT EXECUTED
   203a0:	eb008434 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf (" max. held buffers: %" PRId32 "\n",   fs->max_held_buffers);
   203a4:	e594103c 	ldr	r1, [r4, #60]	; 0x3c                          <== NOT EXECUTED
   203a8:	e59f0104 	ldr	r0, [pc, #260]	; 204b4 <rtems_rfs_shell_data+0x1fc><== NOT EXECUTED
   203ac:	eb008431 	bl	41478 <printf>                                 <== NOT EXECUTED
   203b0:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   203b4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   203b8:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   203bc:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   203c0:	ebffad3e 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
   203c4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
   203c8:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
   203cc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   203d0:	eb005b55 	bl	3712c <rtems_rfs_group_usage>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_shell_unlock_rfs (fs);                                    
   203d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   203d8:	ebfffd2b 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
                                                                      
  bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);                
   203dc:	e59d5004 	ldr	r5, [sp, #4]                                  <== NOT EXECUTED
   203e0:	e3a07ffa 	mov	r7, #1000	; 0x3e8                             <== NOT EXECUTED
   203e4:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
   203e8:	e0000597 	mul	r0, r7, r5                                    <== NOT EXECUTED
   203ec:	eb00d281 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   203f0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);                
   203f4:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
   203f8:	e5941010 	ldr	r1, [r4, #16]                                 <== NOT EXECUTED
   203fc:	e0000097 	mul	r0, r7, r0                                    <== NOT EXECUTED
   20400:	eb00d27c 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
                                                                      
  printf ("       blocks used: %zd (%d.%d%%)\n",                      
   20404:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
                                                                      
  rtems_rfs_shell_unlock_rfs (fs);                                    
                                                                      
  bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);                
  ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);                
   20408:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  printf ("       blocks used: %zd (%d.%d%%)\n",                      
   2040c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   20410:	eb00d2bc 	bl	54f08 <__aeabi_idiv>                           <== NOT EXECUTED
   20414:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
   20418:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   2041c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   20420:	eb00d33b 	bl	55114 <__modsi3>                               <== NOT EXECUTED
   20424:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   20428:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   2042c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   20430:	e59f0080 	ldr	r0, [pc, #128]	; 204b8 <rtems_rfs_shell_data+0x200><== NOT EXECUTED
   20434:	eb00840f 	bl	41478 <printf>                                 <== NOT EXECUTED
          blocks, bpcent / 10, bpcent % 10);                          
  printf ("       inodes used: %zd (%d.%d%%)\n",                      
   20438:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   2043c:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
   20440:	eb00d2b0 	bl	54f08 <__aeabi_idiv>                           <== NOT EXECUTED
   20444:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
   20448:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   2044c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   20450:	eb00d32f 	bl	55114 <__modsi3>                               <== NOT EXECUTED
   20454:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   20458:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   2045c:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
   20460:	e59f0054 	ldr	r0, [pc, #84]	; 204bc <rtems_rfs_shell_data+0x204><== NOT EXECUTED
   20464:	eb008403 	bl	41478 <printf>                                 <== NOT EXECUTED
          inodes, ipcent / 10, ipcent % 10);                          
                                                                      
  return 0;                                                           
}                                                                     
   20468:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   2046c:	e8bd80fc 	pop	{r2, r3, r4, r5, r6, r7, pc}                  <== NOT EXECUTED
                                                                      

0001fe44 <rtems_rfs_shell_dir>: return 0; } static int rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[]) {
   1fe44:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  bool                    state;                                      
  int                     entry;                                      
  int                     b;                                          
  int                     rc;                                         
                                                                      
  if (argc <= 1)                                                      
   1fe48:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{                                                                     
   1fe4c:	e24dd020 	sub	sp, sp, #32                                   <== NOT EXECUTED
   1fe50:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  bool                    state;                                      
  int                     entry;                                      
  int                     b;                                          
  int                     rc;                                         
                                                                      
  if (argc <= 1)                                                      
   1fe54:	ca000002 	bgt	1fe64 <rtems_rfs_shell_dir+0x20>              <== NOT EXECUTED
  {                                                                   
    printf ("error: no block number provided\n");                     
   1fe58:	e59f0268 	ldr	r0, [pc, #616]	; 200c8 <rtems_rfs_shell_dir+0x284><== NOT EXECUTED
   1fe5c:	eb00862a 	bl	4170c <puts>                                   <== NOT EXECUTED
   1fe60:	ea00003c 	b	1ff58 <rtems_rfs_shell_dir+0x114>               <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  block = strtoul (argv[1], 0, 0);                                    
   1fe64:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1fe68:	e5920004 	ldr	r0, [r2, #4]                                  <== NOT EXECUTED
   1fe6c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1fe70:	eb00943b 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1fe74:	e595307c 	ldr	r3, [r5, #124]	; 0x7c                         <== NOT EXECUTED
   1fe78:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1fe7c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1fe80:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   1fe84:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   1fe88:	ebffae8c 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);        
   1fe8c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1fe90:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1fe94:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   1fe98:	e28d301f 	add	r3, sp, #31                                   <== NOT EXECUTED
   1fe9c:	eb005cc7 	bl	371c0 <rtems_rfs_group_bitmap_test>            <== NOT EXECUTED
  if (rc > 0)                                                         
   1fea0:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1fea4:	da000008 	ble	1fecc <rtems_rfs_shell_dir+0x88>              <== NOT EXECUTED
  {                                                                   
    rtems_rfs_shell_unlock_rfs (fs);                                  
   1fea8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1feac:	ebfffe76 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
    printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
   1feb0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1feb4:	eb008d82 	bl	434c4 <strerror>                               <== NOT EXECUTED
   1feb8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1febc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1fec0:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1fec4:	e59f0200 	ldr	r0, [pc, #512]	; 200cc <rtems_rfs_shell_dir+0x288><== NOT EXECUTED
   1fec8:	ea000021 	b	1ff54 <rtems_rfs_shell_dir+0x110>               <== NOT EXECUTED
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
   1fecc:	e5dd101f 	ldrb	r1, [sp, #31]                                <== NOT EXECUTED
   1fed0:	e59f31f8 	ldr	r3, [pc, #504]	; 200d0 <rtems_rfs_shell_dir+0x28c><== NOT EXECUTED
   1fed4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   1fed8:	e59f21f4 	ldr	r2, [pc, #500]	; 200d4 <rtems_rfs_shell_dir+0x290><== NOT EXECUTED
   1fedc:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1fee0:	01a02003 	moveq	r2, r3                                      <== NOT EXECUTED
   1fee4:	e59f01ec 	ldr	r0, [pc, #492]	; 200d8 <rtems_rfs_shell_dir+0x294><== NOT EXECUTED
    printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);    
   1fee8:	e28d6010 	add	r6, sp, #16                                   <== NOT EXECUTED
    printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
   1feec:	eb008561 	bl	41478 <printf>                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   1fef0:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
    printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);    
   1fef4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1fef8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1fefc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   1ff00:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1ff04:	e5cd8010 	strb	r8, [sp, #16]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   1ff08:	e58d8014 	str	r8, [sp, #20]                                 <== NOT EXECUTED
  handle->buffer = NULL;                                              
   1ff0c:	e58d8018 	str	r8, [sp, #24]                                 <== NOT EXECUTED
   1ff10:	eb0051f2 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
  if (rc > 0)                                                         
   1ff14:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
   1ff18:	da000010 	ble	1ff60 <rtems_rfs_shell_dir+0x11c>             <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   1ff1c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1ff20:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1ff24:	eb0051a4 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &buffer);                      
    rtems_rfs_shell_unlock_rfs (fs);                                  
   1ff28:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   1ff2c:	e58d8018 	str	r8, [sp, #24]                                 <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   1ff30:	e5cd8010 	strb	r8, [sp, #16]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   1ff34:	e58d8014 	str	r8, [sp, #20]                                 <== NOT EXECUTED
   1ff38:	ebfffe53 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
    printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
   1ff3c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   1ff40:	eb008d5f 	bl	434c4 <strerror>                               <== NOT EXECUTED
   1ff44:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1ff48:	e59f018c 	ldr	r0, [pc, #396]	; 200dc <rtems_rfs_shell_dir+0x298><== NOT EXECUTED
   1ff4c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1ff50:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1ff54:	eb008547 	bl	41478 <printf>                                 <== NOT EXECUTED
   1ff58:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
            block, rc, strerror (rc));                                
    return 1;                                                         
   1ff5c:	ea000057 	b	200c0 <rtems_rfs_shell_dir+0x27c>               <== NOT EXECUTED
  }                                                                   
                                                                      
  b = 0;                                                              
  entry = 1;                                                          
  data = rtems_rfs_buffer_data (&buffer);                             
   1ff60:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
   1ff64:	e3a07001 	mov	r7, #1                                        <== NOT EXECUTED
   1ff68:	e5934020 	ldr	r4, [r3, #32]                                 <== NOT EXECUTED
    int           c;                                                  
                                                                      
    eino    = rtems_rfs_dir_entry_ino (data);                         
    elength = rtems_rfs_dir_entry_length (data);                      
                                                                      
    if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                         
   1ff6c:	e59f916c 	ldr	r9, [pc, #364]	; 200e0 <rtems_rfs_shell_dir+0x29c><== NOT EXECUTED
                                                                      
  b = 0;                                                              
  entry = 1;                                                          
  data = rtems_rfs_buffer_data (&buffer);                             
                                                                      
  while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
   1ff70:	ea000044 	b	20088 <rtems_rfs_shell_dir+0x244>               <== NOT EXECUTED
    int           elength;                                            
    int           length;                                             
    int           c;                                                  
                                                                      
    eino    = rtems_rfs_dir_entry_ino (data);                         
    elength = rtems_rfs_dir_entry_length (data);                      
   1ff74:	e5d43009 	ldrb	r3, [r4, #9]                                 <== NOT EXECUTED
   1ff78:	e5d46008 	ldrb	r6, [r4, #8]                                 <== NOT EXECUTED
   1ff7c:	e1836406 	orr	r6, r3, r6, lsl #8                            <== NOT EXECUTED
                                                                      
    if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                         
   1ff80:	e1560009 	cmp	r6, r9                                        <== NOT EXECUTED
    rtems_rfs_ino eino;                                               
    int           elength;                                            
    int           length;                                             
    int           c;                                                  
                                                                      
    eino    = rtems_rfs_dir_entry_ino (data);                         
   1ff84:	e5d40000 	ldrb	r0, [r4]                                     <== NOT EXECUTED
   1ff88:	e5d41001 	ldrb	r1, [r4, #1]                                 <== NOT EXECUTED
   1ff8c:	e5d42002 	ldrb	r2, [r4, #2]                                 <== NOT EXECUTED
   1ff90:	e5d43003 	ldrb	r3, [r4, #3]                                 <== NOT EXECUTED
    elength = rtems_rfs_dir_entry_length (data);                      
                                                                      
    if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                         
   1ff94:	0a00003f 	beq	20098 <rtems_rfs_shell_dir+0x254>             <== NOT EXECUTED
      break;                                                          
                                                                      
    if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||                       
   1ff98:	e3560009 	cmp	r6, #9                                        <== NOT EXECUTED
   1ff9c:	da000002 	ble	1ffac <rtems_rfs_shell_dir+0x168>             <== NOT EXECUTED
        (elength >= rtems_rfs_fs_max_name (fs)))                      
   1ffa0:	e595c018 	ldr	ip, [r5, #24]                                 <== NOT EXECUTED
   1ffa4:	e156000c 	cmp	r6, ip                                        <== NOT EXECUTED
   1ffa8:	3a000003 	bcc	1ffbc <rtems_rfs_shell_dir+0x178>             <== NOT EXECUTED
    {                                                                 
      printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
   1ffac:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1ffb0:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1ffb4:	e59f0128 	ldr	r0, [pc, #296]	; 200e4 <rtems_rfs_shell_dir+0x2a0><== NOT EXECUTED
   1ffb8:	ea000009 	b	1ffe4 <rtems_rfs_shell_dir+0x1a0>               <== NOT EXECUTED
    rtems_rfs_ino eino;                                               
    int           elength;                                            
    int           length;                                             
    int           c;                                                  
                                                                      
    eino    = rtems_rfs_dir_entry_ino (data);                         
   1ffbc:	e1833c00 	orr	r3, r3, r0, lsl #24                           <== NOT EXECUTED
   1ffc0:	e1833801 	orr	r3, r3, r1, lsl #16                           <== NOT EXECUTED
    {                                                                 
      printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
      break;                                                          
    }                                                                 
                                                                      
    if ((eino < RTEMS_RFS_ROOT_INO) || (eino >= rtems_rfs_fs_inodes (fs)))
   1ffc4:	e1933402 	orrs	r3, r3, r2, lsl #8                           <== NOT EXECUTED
   1ffc8:	0a000002 	beq	1ffd8 <rtems_rfs_shell_dir+0x194>             <== NOT EXECUTED
   1ffcc:	e5952010 	ldr	r2, [r5, #16]                                 <== NOT EXECUTED
   1ffd0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   1ffd4:	3a000004 	bcc	1ffec <rtems_rfs_shell_dir+0x1a8>             <== NOT EXECUTED
    {                                                                 
      printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
   1ffd8:	e59f0108 	ldr	r0, [pc, #264]	; 200e8 <rtems_rfs_shell_dir+0x2a4><== NOT EXECUTED
   1ffdc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1ffe0:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
   1ffe4:	eb008523 	bl	41478 <printf>                                 <== NOT EXECUTED
      break;                                                          
   1ffe8:	ea00002a 	b	20098 <rtems_rfs_shell_dir+0x254>               <== NOT EXECUTED
    }                                                                 
                                                                      
    length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;                      
                                                                      
    printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
   1ffec:	e5d4c005 	ldrb	ip, [r4, #5]                                 <== NOT EXECUTED
   1fff0:	e5d42004 	ldrb	r2, [r4, #4]                                 <== NOT EXECUTED
   1fff4:	e5d41007 	ldrb	r1, [r4, #7]                                 <== NOT EXECUTED
   1fff8:	e1a0c80c 	lsl	ip, ip, #16                                   <== NOT EXECUTED
   1fffc:	e18ccc02 	orr	ip, ip, r2, lsl #24                           <== NOT EXECUTED
   20000:	e5d42006 	ldrb	r2, [r4, #6]                                 <== NOT EXECUTED
   20004:	e18cc001 	orr	ip, ip, r1                                    <== NOT EXECUTED
   20008:	e18cc402 	orr	ip, ip, r2, lsl #8                            <== NOT EXECUTED
    {                                                                 
      printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
      break;                                                          
    }                                                                 
                                                                      
    length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;                      
   2000c:	e246a00a 	sub	sl, r6, #10                                   <== NOT EXECUTED
                                                                      
    printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
   20010:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   20014:	e59f00d0 	ldr	r0, [pc, #208]	; 200ec <rtems_rfs_shell_dir+0x2a8><== NOT EXECUTED
   20018:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   2001c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   20020:	e58da004 	str	sl, [sp, #4]                                  <== NOT EXECUTED
   20024:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
   20028:	eb008512 	bl	41478 <printf>                                 <== NOT EXECUTED
   2002c:	e35a0032 	cmp	sl, #50	; 0x32                                <== NOT EXECUTED
   20030:	b1a0200a 	movlt	r2, sl                                      <== NOT EXECUTED
   20034:	a3a02032 	movge	r2, #50	; 0x32                              <== NOT EXECUTED
   20038:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
            length);                                                  
                                                                      
    if (length > 50)                                                  
      length = 50;                                                    
                                                                      
    for (c = 0; c < length; c++)                                      
   2003c:	ea000006 	b	2005c <rtems_rfs_shell_dir+0x218>               <== NOT EXECUTED
      printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);              
   20040:	e5d30009 	ldrb	r0, [r3, #9]                                 <== NOT EXECUTED
   20044:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
   20048:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
   2004c:	eb00857e 	bl	4164c <putchar>                                <== NOT EXECUTED
            length);                                                  
                                                                      
    if (length > 50)                                                  
      length = 50;                                                    
                                                                      
    for (c = 0; c < length; c++)                                      
   20050:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
   20054:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   20058:	e28bb001 	add	fp, fp, #1                                    <== NOT EXECUTED
   2005c:	e15b0002 	cmp	fp, r2                                        <== NOT EXECUTED
   20060:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
   20064:	bafffff5 	blt	20040 <rtems_rfs_shell_dir+0x1fc>             <== NOT EXECUTED
      printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);              
    if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)                  
   20068:	e152000a 	cmp	r2, sl                                        <== NOT EXECUTED
      printf ("...");                                                 
   2006c:	b59f007c 	ldrlt	r0, [pc, #124]	; 200f0 <rtems_rfs_shell_dir+0x2ac><== NOT EXECUTED
   20070:	bb008500 	bllt	41478 <printf>                               <== NOT EXECUTED
    printf ("\n");                                                    
   20074:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
   20078:	eb008573 	bl	4164c <putchar>                                <== NOT EXECUTED
                                                                      
    b += elength;                                                     
    data += elength;                                                  
   2007c:	e0844006 	add	r4, r4, r6                                    <== NOT EXECUTED
      printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);              
    if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)                  
      printf ("...");                                                 
    printf ("\n");                                                    
                                                                      
    b += elength;                                                     
   20080:	e0888006 	add	r8, r8, r6                                    <== NOT EXECUTED
    data += elength;                                                  
    entry++;                                                          
   20084:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
                                                                      
  b = 0;                                                              
  entry = 1;                                                          
  data = rtems_rfs_buffer_data (&buffer);                             
                                                                      
  while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
   20088:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
   2008c:	e243300b 	sub	r3, r3, #11                                   <== NOT EXECUTED
   20090:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
   20094:	3affffb6 	bcc	1ff74 <rtems_rfs_shell_dir+0x130>             <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   20098:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
   2009c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   200a0:	eb005145 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
  handle->dirty = false;                                              
   200a4:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
    printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n",
            block, rc, strerror (rc));                                
    return 1;                                                         
  }                                                                   
                                                                      
  rtems_rfs_shell_unlock_rfs (fs);                                    
   200a8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   200ac:	e5cd4010 	strb	r4, [sp, #16]                                <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   200b0:	e58d4014 	str	r4, [sp, #20]                                 <== NOT EXECUTED
  handle->buffer = NULL;                                              
   200b4:	e58d4018 	str	r4, [sp, #24]                                 <== NOT EXECUTED
   200b8:	ebfffdf3 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
   200bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   200c0:	e28dd020 	add	sp, sp, #32                                   <== NOT EXECUTED
   200c4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0001fcd8 <rtems_rfs_shell_group>: int g; start = 0; end = fs->group_count - 1; switch (argc)
   1fcd8:	e3510002 	cmp	r1, #2                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{                                                                     
   1fcdc:	e92d4fff 	push	{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
   1fce0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   1fce4:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
  int start;                                                          
  int end;                                                            
  int g;                                                              
                                                                      
  start = 0;                                                          
  end = fs->group_count - 1;                                          
   1fce8:	e5905020 	ldr	r5, [r0, #32]                                 <== NOT EXECUTED
                                                                      
  switch (argc)                                                       
   1fcec:	0a000004 	beq	1fd04 <rtems_rfs_shell_group+0x2c>            <== NOT EXECUTED
   1fcf0:	e3510003 	cmp	r1, #3                                        <== NOT EXECUTED
   1fcf4:	0a000009 	beq	1fd20 <rtems_rfs_shell_group+0x48>            <== NOT EXECUTED
   1fcf8:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
   1fcfc:	1a000012 	bne	1fd4c <rtems_rfs_shell_group+0x74>            <== NOT EXECUTED
   1fd00:	ea000014 	b	1fd58 <rtems_rfs_shell_group+0x80>              <== NOT EXECUTED
  {                                                                   
    case 1:                                                           
      break;                                                          
    case 2:                                                           
      start = end = strtoul (argv[1], 0, 0);                          
   1fd04:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1fd08:	e5920004 	ldr	r0, [r2, #4]                                  <== NOT EXECUTED
   1fd0c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1fd10:	eb009493 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1fd14:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   1fd18:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
      break;                                                          
   1fd1c:	ea00000f 	b	1fd60 <rtems_rfs_shell_group+0x88>              <== NOT EXECUTED
    case 3:                                                           
      start = strtoul (argv[1], 0, 0);                                
   1fd20:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1fd24:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1fd28:	e5970004 	ldr	r0, [r7, #4]                                  <== NOT EXECUTED
   1fd2c:	eb00948c 	bl	44f64 <strtoul>                                <== NOT EXECUTED
      end = strtoul (argv[2], 0, 0);                                  
   1fd30:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
      break;                                                          
    case 2:                                                           
      start = end = strtoul (argv[1], 0, 0);                          
      break;                                                          
    case 3:                                                           
      start = strtoul (argv[1], 0, 0);                                
   1fd34:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
      end = strtoul (argv[2], 0, 0);                                  
   1fd38:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1fd3c:	e5970008 	ldr	r0, [r7, #8]                                  <== NOT EXECUTED
   1fd40:	eb009487 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1fd44:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
      break;                                                          
   1fd48:	ea000004 	b	1fd60 <rtems_rfs_shell_group+0x88>              <== NOT EXECUTED
    default:                                                          
      printf ("error: too many arguments.\n");                        
   1fd4c:	e59f00e4 	ldr	r0, [pc, #228]	; 1fe38 <rtems_rfs_shell_group+0x160><== NOT EXECUTED
   1fd50:	eb00866d 	bl	4170c <puts>                                   <== NOT EXECUTED
   1fd54:	ea00000c 	b	1fd8c <rtems_rfs_shell_group+0xb4>              <== NOT EXECUTED
  int start;                                                          
  int end;                                                            
  int g;                                                              
                                                                      
  start = 0;                                                          
  end = fs->group_count - 1;                                          
   1fd58:	e2455001 	sub	r5, r5, #1                                    <== NOT EXECUTED
   1fd5c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
    default:                                                          
      printf ("error: too many arguments.\n");                        
      return 1;                                                       
  }                                                                   
                                                                      
  if ((start < 0) || (end < 0) ||                                     
   1fd60:	e1a01fa6 	lsr	r1, r6, #31                                   <== NOT EXECUTED
   1fd64:	e1911fa5 	orrs	r1, r1, r5, lsr #31                          <== NOT EXECUTED
   1fd68:	1a000004 	bne	1fd80 <rtems_rfs_shell_group+0xa8>            <== NOT EXECUTED
      (start >= fs->group_count) || (end >= fs->group_count))         
   1fd6c:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
    default:                                                          
      printf ("error: too many arguments.\n");                        
      return 1;                                                       
  }                                                                   
                                                                      
  if ((start < 0) || (end < 0) ||                                     
   1fd70:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
   1fd74:	aa000001 	bge	1fd80 <rtems_rfs_shell_group+0xa8>            <== NOT EXECUTED
   1fd78:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
   1fd7c:	ba000004 	blt	1fd94 <rtems_rfs_shell_group+0xbc>            <== NOT EXECUTED
      (start >= fs->group_count) || (end >= fs->group_count))         
  {                                                                   
    printf ("error: group out of range (0->%d).\n", fs->group_count); 
   1fd80:	e5941020 	ldr	r1, [r4, #32]                                 <== NOT EXECUTED
   1fd84:	e59f00b0 	ldr	r0, [pc, #176]	; 1fe3c <rtems_rfs_shell_group+0x164><== NOT EXECUTED
   1fd88:	eb0085ba 	bl	41478 <printf>                                 <== NOT EXECUTED
   1fd8c:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    return 1;                                                         
   1fd90:	ea000026 	b	1fe30 <rtems_rfs_shell_group+0x158>             <== NOT EXECUTED
   1fd94:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   1fd98:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1fd9c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   1fda0:	ebffaec6 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
   1fda4:	e3a03050 	mov	r3, #80	; 0x50                                <== NOT EXECUTED
   1fda8:	e0070693 	mul	r7, r3, r6                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  for (g = start; g <= end; g++)                                      
   1fdac:	ea00001a 	b	1fe1c <rtems_rfs_shell_group+0x144>             <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
   1fdb0:	e594801c 	ldr	r8, [r4, #28]                                 <== NOT EXECUTED
   1fdb4:	e0882007 	add	r2, r8, r7                                    <== NOT EXECUTED
    size_t           blocks;                                          
    size_t           inodes;                                          
    blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
   1fdb8:	e592a004 	ldr	sl, [r2, #4]                                  <== NOT EXECUTED
   1fdbc:	e5923018 	ldr	r3, [r2, #24]                                 <== NOT EXECUTED
    inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
    printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
   1fdc0:	e3a00064 	mov	r0, #100	; 0x64                               <== NOT EXECUTED
  for (g = start; g <= end; g++)                                      
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    size_t           blocks;                                          
    size_t           inodes;                                          
    blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
   1fdc4:	e063300a 	rsb	r3, r3, sl                                    <== NOT EXECUTED
    inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
    printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
   1fdc8:	e0000093 	mul	r0, r3, r0                                    <== NOT EXECUTED
   1fdcc:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    size_t           blocks;                                          
    size_t           inodes;                                          
    blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
    inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
   1fdd0:	e592903c 	ldr	r9, [r2, #60]	; 0x3c                          <== NOT EXECUTED
   1fdd4:	e594b028 	ldr	fp, [r4, #40]	; 0x28                          <== NOT EXECUTED
    printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
   1fdd8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
   1fddc:	eb00d405 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    size_t           blocks;                                          
    size_t           inodes;                                          
    blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
    inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
   1fde0:	e069900b 	rsb	r9, r9, fp                                    <== NOT EXECUTED
    printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
   1fde4:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
   1fde8:	e3a00064 	mov	r0, #100	; 0x64                               <== NOT EXECUTED
   1fdec:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   1fdf0:	e0000099 	mul	r0, r9, r0                                    <== NOT EXECUTED
   1fdf4:	e58d9008 	str	r9, [sp, #8]                                  <== NOT EXECUTED
   1fdf8:	eb00d3fe 	bl	54df8 <__aeabi_uidiv>                          <== NOT EXECUTED
   1fdfc:	e58d000c 	str	r0, [sp, #12]                                 <== NOT EXECUTED
   1fe00:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1fe04:	e7982007 	ldr	r2, [r8, r7]                                  <== NOT EXECUTED
   1fe08:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   1fe0c:	e59f002c 	ldr	r0, [pc, #44]	; 1fe40 <rtems_rfs_shell_group+0x168><== NOT EXECUTED
   1fe10:	eb008598 	bl	41478 <printf>                                 <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  for (g = start; g <= end; g++)                                      
   1fe14:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   1fe18:	e2877050 	add	r7, r7, #80	; 0x50                            <== NOT EXECUTED
   1fe1c:	e1560005 	cmp	r6, r5                                        <== NOT EXECUTED
   1fe20:	daffffe2 	ble	1fdb0 <rtems_rfs_shell_group+0xd8>            <== NOT EXECUTED
            g, group->base, group->size,                              
            blocks, (blocks * 100)  / group->size,                    
            inodes, (inodes * 100) / fs->group_inodes);               
  }                                                                   
                                                                      
  rtems_rfs_shell_unlock_rfs (fs);                                    
   1fe24:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fe28:	ebfffe97 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
   1fe2c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1fe30:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
   1fe34:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0001f8a4 <rtems_rfs_shell_inode>: return 0; } static int rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[]) {
   1f8a4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  bool          have_end;                                             
  int           arg;                                                  
  int           b;                                                    
  int           rc;                                                   
                                                                      
  total = fs->group_inodes * fs->group_count;                         
   1f8a8:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{                                                                     
   1f8ac:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  bool          have_end;                                             
  int           arg;                                                  
  int           b;                                                    
  int           rc;                                                   
                                                                      
  total = fs->group_inodes * fs->group_count;                         
   1f8b0:	e5900028 	ldr	r0, [r0, #40]	; 0x28                          <== NOT EXECUTED
   1f8b4:	e0070390 	mul	r7, r0, r3                                    <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{                                                                     
   1f8b8:	e24dd04c 	sub	sp, sp, #76	; 0x4c                            <== NOT EXECUTED
  int           b;                                                    
  int           rc;                                                   
                                                                      
  total = fs->group_inodes * fs->group_count;                         
  start = RTEMS_RFS_ROOT_INO;                                         
  end = total - 1;                                                    
   1f8bc:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
   1f8c0:	e247b001 	sub	fp, r7, #1                                    <== NOT EXECUTED
   1f8c4:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{                                                                     
   1f8c8:	e58d1018 	str	r1, [sp, #24]                                 <== NOT EXECUTED
   1f8cc:	e58d201c 	str	r2, [sp, #28]                                 <== NOT EXECUTED
  int           b;                                                    
  int           rc;                                                   
                                                                      
  total = fs->group_inodes * fs->group_count;                         
  start = RTEMS_RFS_ROOT_INO;                                         
  end = total - 1;                                                    
   1f8d0:	e1a0500b 	mov	r5, fp                                        <== NOT EXECUTED
   1f8d4:	e1a0a006 	mov	sl, r6                                        <== NOT EXECUTED
   1f8d8:	e58d600c 	str	r6, [sp, #12]                                 <== NOT EXECUTED
   1f8dc:	e58d6010 	str	r6, [sp, #16]                                 <== NOT EXECUTED
   1f8e0:	e58d6014 	str	r6, [sp, #20]                                 <== NOT EXECUTED
   1f8e4:	e1a09008 	mov	r9, r8                                        <== NOT EXECUTED
  show_all = false;                                                   
  error_check_only = false;                                           
  forced = false;                                                     
  have_start = have_end = false;                                      
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
   1f8e8:	ea000029 	b	1f994 <rtems_rfs_shell_inode+0xf0>              <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
   1f8ec:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
   1f8f0:	e7910108 	ldr	r0, [r1, r8, lsl #2]                          <== NOT EXECUTED
   1f8f4:	e5d03000 	ldrb	r3, [r0]                                     <== NOT EXECUTED
   1f8f8:	e353002d 	cmp	r3, #45	; 0x2d                                <== NOT EXECUTED
   1f8fc:	1a00000d 	bne	1f938 <rtems_rfs_shell_inode+0x94>            <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
   1f900:	e5d03001 	ldrb	r3, [r0, #1]                                 <== NOT EXECUTED
   1f904:	e3530065 	cmp	r3, #101	; 0x65                               <== NOT EXECUTED
   1f908:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
   1f90c:	058d2010 	streq	r2, [sp, #16]                               <== NOT EXECUTED
   1f910:	0a00001e 	beq	1f990 <rtems_rfs_shell_inode+0xec>            <== NOT EXECUTED
   1f914:	e3530066 	cmp	r3, #102	; 0x66                               <== NOT EXECUTED
   1f918:	03a01001 	moveq	r1, #1                                      <== NOT EXECUTED
   1f91c:	058d100c 	streq	r1, [sp, #12]                               <== NOT EXECUTED
   1f920:	0a00001a 	beq	1f990 <rtems_rfs_shell_inode+0xec>            <== NOT EXECUTED
   1f924:	e3530061 	cmp	r3, #97	; 0x61                                <== NOT EXECUTED
   1f928:	1a000006 	bne	1f948 <rtems_rfs_shell_inode+0xa4>            <== NOT EXECUTED
   1f92c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1f930:	e58d3014 	str	r3, [sp, #20]                                 <== NOT EXECUTED
   1f934:	ea000015 	b	1f990 <rtems_rfs_shell_inode+0xec>              <== NOT EXECUTED
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (have_end && have_start)                                     
   1f938:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   1f93c:	0a000005 	beq	1f958 <rtems_rfs_shell_inode+0xb4>            <== NOT EXECUTED
   1f940:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   1f944:	0a000005 	beq	1f960 <rtems_rfs_shell_inode+0xbc>            <== NOT EXECUTED
        printf ("warning: option ignored: %s\n", argv[arg]);          
   1f948:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   1f94c:	e59f0340 	ldr	r0, [pc, #832]	; 1fc94 <rtems_rfs_shell_inode+0x3f0><== NOT EXECUTED
   1f950:	eb0086c8 	bl	41478 <printf>                                 <== NOT EXECUTED
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (have_end && have_start)                                     
   1f954:	ea00000d 	b	1f990 <rtems_rfs_shell_inode+0xec>              <== NOT EXECUTED
        printf ("warning: option ignored: %s\n", argv[arg]);          
      else if (!have_start)                                           
   1f958:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
   1f95c:	1a000006 	bne	1f97c <rtems_rfs_shell_inode+0xd8>            <== NOT EXECUTED
      {                                                               
        start = end = strtoul (argv[arg], 0, 0);                      
   1f960:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1f964:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1f968:	eb00957d 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1f96c:	e3a0a001 	mov	sl, #1                                        <== NOT EXECUTED
   1f970:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   1f974:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
   1f978:	ea000004 	b	1f990 <rtems_rfs_shell_inode+0xec>              <== NOT EXECUTED
        have_start = true;                                            
      }                                                               
      else                                                            
      {                                                               
        end = strtoul (argv[arg], 0, 0);                              
   1f97c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   1f980:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1f984:	eb009576 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1f988:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
   1f98c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  show_all = false;                                                   
  error_check_only = false;                                           
  forced = false;                                                     
  have_start = have_end = false;                                      
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
   1f990:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
   1f994:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
   1f998:	e1580002 	cmp	r8, r2                                        <== NOT EXECUTED
   1f99c:	baffffd2 	blt	1f8ec <rtems_rfs_shell_inode+0x48>            <== NOT EXECUTED
        have_end = true;                                              
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ((start >= total) || (end >= total))                             
   1f9a0:	e1590007 	cmp	r9, r7                                        <== NOT EXECUTED
   1f9a4:	31550007 	cmpcc	r5, r7                                      <== NOT EXECUTED
   1f9a8:	33a01000 	movcc	r1, #0                                      <== NOT EXECUTED
   1f9ac:	23a01001 	movcs	r1, #1                                      <== NOT EXECUTED
   1f9b0:	3a000003 	bcc	1f9c4 <rtems_rfs_shell_inode+0x120>           <== NOT EXECUTED
  {                                                                   
    printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
   1f9b4:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   1f9b8:	e59f02d8 	ldr	r0, [pc, #728]	; 1fc98 <rtems_rfs_shell_inode+0x3f4><== NOT EXECUTED
   1f9bc:	eb0086ad 	bl	41478 <printf>                                 <== NOT EXECUTED
   1f9c0:	ea000018 	b	1fa28 <rtems_rfs_shell_inode+0x184>             <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)                         
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
   1f9c4:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
   1f9c8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1f9cc:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   1f9d0:	ebffafba 	bl	b8c0 <rtems_semaphore_obtain>                  <== NOT EXECUTED
  for (ino = start; ino <= end; ino++)                                
  {                                                                   
    rtems_rfs_inode_handle inode;                                     
    bool                   allocated;                                 
                                                                      
    rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);     
   1f9d4:	e28da04b 	add	sl, sp, #75	; 0x4b                            <== NOT EXECUTED
    if (show_all || allocated)                                        
    {                                                                 
      uint16_t mode;                                                  
      bool     error;                                                 
                                                                      
      rc = rtems_rfs_inode_open (fs, ino, &inode, true);              
   1f9d8:	e28d7020 	add	r7, sp, #32                                   <== NOT EXECUTED
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
  if (links == 0xffff)                                                
   1f9dc:	e59fb2b8 	ldr	fp, [pc, #696]	; 1fc9c <rtems_rfs_shell_inode+0x3f8><== NOT EXECUTED
   1f9e0:	e1a08005 	mov	r8, r5                                        <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  for (ino = start; ino <= end; ino++)                                
   1f9e4:	ea0000a3 	b	1fc78 <rtems_rfs_shell_inode+0x3d4>             <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_handle inode;                                     
    bool                   allocated;                                 
                                                                      
    rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);     
   1f9e8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1f9ec:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   1f9f0:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
   1f9f4:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
   1f9f8:	eb005df0 	bl	371c0 <rtems_rfs_group_bitmap_test>            <== NOT EXECUTED
    if (rc > 0)                                                       
   1f9fc:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1fa00:	da00000a 	ble	1fa30 <rtems_rfs_shell_inode+0x18c>           <== NOT EXECUTED
    {                                                                 
      rtems_rfs_shell_unlock_rfs (fs);                                
   1fa04:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fa08:	ebffff9f 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
      printf ("error: testing inode state: ino=%" PRIu32 ": (%d) %s\n",
   1fa0c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1fa10:	eb008eab 	bl	434c4 <strerror>                               <== NOT EXECUTED
   1fa14:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1fa18:	e59f0280 	ldr	r0, [pc, #640]	; 1fca0 <rtems_rfs_shell_inode+0x3fc><== NOT EXECUTED
   1fa1c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1fa20:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1fa24:	eb008693 	bl	41478 <printf>                                 <== NOT EXECUTED
   1fa28:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
              ino, rc, strerror (rc));                                
      return 1;                                                       
   1fa2c:	ea000096 	b	1fc8c <rtems_rfs_shell_inode+0x3e8>             <== NOT EXECUTED
    }                                                                 
                                                                      
    if (show_all || allocated)                                        
   1fa30:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
   1fa34:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1fa38:	1a000002 	bne	1fa48 <rtems_rfs_shell_inode+0x1a4>           <== NOT EXECUTED
   1fa3c:	e5dd304b 	ldrb	r3, [sp, #75]	; 0x4b                         <== NOT EXECUTED
   1fa40:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1fa44:	0a00008a 	beq	1fc74 <rtems_rfs_shell_inode+0x3d0>           <== NOT EXECUTED
    {                                                                 
      uint16_t mode;                                                  
      bool     error;                                                 
                                                                      
      rc = rtems_rfs_inode_open (fs, ino, &inode, true);              
   1fa48:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fa4c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1fa50:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   1fa54:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   1fa58:	eb005fc9 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
      if (rc > 0)                                                     
   1fa5c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1fa60:	da000008 	ble	1fa88 <rtems_rfs_shell_inode+0x1e4>           <== NOT EXECUTED
      {                                                               
        rtems_rfs_shell_unlock_rfs (fs);                              
   1fa64:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fa68:	ebffff87 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
        printf ("error: opening inode handle: ino=%" PRIu32 ": (%d) %s\n",
   1fa6c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1fa70:	eb008e93 	bl	434c4 <strerror>                               <== NOT EXECUTED
   1fa74:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1fa78:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1fa7c:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1fa80:	e59f021c 	ldr	r0, [pc, #540]	; 1fca4 <rtems_rfs_shell_inode+0x400><== NOT EXECUTED
   1fa84:	eaffffe6 	b	1fa24 <rtems_rfs_shell_inode+0x180>             <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   1fa88:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
                                                                      
      error = false;                                                  
                                                                      
      mode = rtems_rfs_inode_get_mode (&inode);                       
                                                                      
      if (error_check_only)                                           
   1fa8c:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   1fa90:	e5d32003 	ldrb	r2, [r3, #3]                                 <== NOT EXECUTED
   1fa94:	e5d35002 	ldrb	r5, [r3, #2]                                 <== NOT EXECUTED
   1fa98:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   1fa9c:	e1825405 	orr	r5, r2, r5, lsl #8                            <== NOT EXECUTED
   1faa0:	0a000009 	beq	1facc <rtems_rfs_shell_inode+0x228>           <== NOT EXECUTED
      {                                                               
        if (!RTEMS_RFS_S_ISDIR (mode) &&                              
   1faa4:	e2053a0f 	and	r3, r5, #61440	; 0xf000                       <== NOT EXECUTED
   1faa8:	e3530a02 	cmp	r3, #8192	; 0x2000                            <== NOT EXECUTED
   1faac:	13530901 	cmpne	r3, #16384	; 0x4000                         <== NOT EXECUTED
   1fab0:	0a000061 	beq	1fc3c <rtems_rfs_shell_inode+0x398>           <== NOT EXECUTED
   1fab4:	e3530a06 	cmp	r3, #24576	; 0x6000                           <== NOT EXECUTED
   1fab8:	0a00005f 	beq	1fc3c <rtems_rfs_shell_inode+0x398>           <== NOT EXECUTED
   1fabc:	e3530902 	cmp	r3, #32768	; 0x8000                           <== NOT EXECUTED
   1fac0:	0a00005d 	beq	1fc3c <rtems_rfs_shell_inode+0x398>           <== NOT EXECUTED
          }                                                           
#endif                                                                
        }                                                             
      }                                                               
                                                                      
      if (!error_check_only || error)                                 
   1fac4:	e3530a0a 	cmp	r3, #40960	; 0xa000                           <== NOT EXECUTED
   1fac8:	0a00005b 	beq	1fc3c <rtems_rfs_shell_inode+0x398>           <== NOT EXECUTED
      {                                                               
        printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",         
   1facc:	e5ddc04b 	ldrb	ip, [sp, #75]	; 0x4b                         <== NOT EXECUTED
   1fad0:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
   1fad4:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
   1fad8:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
   1fadc:	13a0c041 	movne	ip, #65	; 0x41                              <== NOT EXECUTED
   1fae0:	03a0c046 	moveq	ip, #70	; 0x46                              <== NOT EXECUTED
   1fae4:	e0030392 	mul	r3, r2, r3                                    <== NOT EXECUTED
   1fae8:	e59f01b8 	ldr	r0, [pc, #440]	; 1fca8 <rtems_rfs_shell_inode+0x404><== NOT EXECUTED
   1faec:	e59d2034 	ldr	r2, [sp, #52]	; 0x34                          <== NOT EXECUTED
   1faf0:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1faf4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   1faf8:	eb00865e 	bl	41478 <printf>                                 <== NOT EXECUTED
                ino, rtems_rfs_buffer_bnum (&inode.buffer),           
                inode.offset * RTEMS_RFS_INODE_SIZE,                  
                allocated ? 'A' : 'F');                               
                                                                      
        if (!allocated && !forced)                                    
   1fafc:	e5dd304b 	ldrb	r3, [sp, #75]	; 0x4b                         <== NOT EXECUTED
   1fb00:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   1fb04:	1a000005 	bne	1fb20 <rtems_rfs_shell_inode+0x27c>           <== NOT EXECUTED
   1fb08:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   1fb0c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
   1fb10:	1a000002 	bne	1fb20 <rtems_rfs_shell_inode+0x27c>           <== NOT EXECUTED
          printf (" --\n");                                           
   1fb14:	e59f0190 	ldr	r0, [pc, #400]	; 1fcac <rtems_rfs_shell_inode+0x408><== NOT EXECUTED
   1fb18:	eb0086fb 	bl	4170c <puts>                                   <== NOT EXECUTED
        printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",         
                ino, rtems_rfs_buffer_bnum (&inode.buffer),           
                inode.offset * RTEMS_RFS_INODE_SIZE,                  
                allocated ? 'A' : 'F');                               
                                                                      
        if (!allocated && !forced)                                    
   1fb1c:	ea000046 	b	1fc3c <rtems_rfs_shell_inode+0x398>             <== NOT EXECUTED
          printf (" --\n");                                           
        else                                                          
        {                                                             
          const char* type;                                           
          type = "UKN";                                               
          if (RTEMS_RFS_S_ISDIR (mode))                               
   1fb20:	e2053a0f 	and	r3, r5, #61440	; 0xf000                       <== NOT EXECUTED
   1fb24:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
   1fb28:	059f3180 	ldreq	r3, [pc, #384]	; 1fcb0 <rtems_rfs_shell_inode+0x40c><== NOT EXECUTED
   1fb2c:	0a00000d 	beq	1fb68 <rtems_rfs_shell_inode+0x2c4>           <== NOT EXECUTED
            type = "DIR";                                             
          else if (RTEMS_RFS_S_ISCHR (mode))                          
   1fb30:	e3530a02 	cmp	r3, #8192	; 0x2000                            <== NOT EXECUTED
   1fb34:	059f3178 	ldreq	r3, [pc, #376]	; 1fcb4 <rtems_rfs_shell_inode+0x410><== NOT EXECUTED
   1fb38:	0a00000a 	beq	1fb68 <rtems_rfs_shell_inode+0x2c4>           <== NOT EXECUTED
            type = "CHR";                                             
          else if (RTEMS_RFS_S_ISBLK (mode))                          
   1fb3c:	e3530a06 	cmp	r3, #24576	; 0x6000                           <== NOT EXECUTED
   1fb40:	059f3170 	ldreq	r3, [pc, #368]	; 1fcb8 <rtems_rfs_shell_inode+0x414><== NOT EXECUTED
   1fb44:	0a000007 	beq	1fb68 <rtems_rfs_shell_inode+0x2c4>           <== NOT EXECUTED
            type = "BLK";                                             
          else if (RTEMS_RFS_S_ISREG (mode))                          
   1fb48:	e3530902 	cmp	r3, #32768	; 0x8000                           <== NOT EXECUTED
   1fb4c:	059f3168 	ldreq	r3, [pc, #360]	; 1fcbc <rtems_rfs_shell_inode+0x418><== NOT EXECUTED
   1fb50:	0a000004 	beq	1fb68 <rtems_rfs_shell_inode+0x2c4>           <== NOT EXECUTED
            type = "REG";                                             
          else if (RTEMS_RFS_S_ISLNK (mode))                          
   1fb54:	e59f2164 	ldr	r2, [pc, #356]	; 1fcc0 <rtems_rfs_shell_inode+0x41c><== NOT EXECUTED
   1fb58:	e59f1164 	ldr	r1, [pc, #356]	; 1fcc4 <rtems_rfs_shell_inode+0x420><== NOT EXECUTED
   1fb5c:	e3530a0a 	cmp	r3, #40960	; 0xa000                           <== NOT EXECUTED
   1fb60:	01a01002 	moveq	r1, r2                                      <== NOT EXECUTED
   1fb64:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   1fb68:	e59d002c 	ldr	r0, [sp, #44]	; 0x2c                          <== NOT EXECUTED
            type = "LNK";                                             
          printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
   1fb6c:	e1a02b05 	lsl	r2, r5, #22                                   <== NOT EXECUTED
   1fb70:	e1a02b22 	lsr	r2, r2, #22                                   <== NOT EXECUTED
   1fb74:	e5d0e000 	ldrb	lr, [r0]                                     <== NOT EXECUTED
   1fb78:	e5d01001 	ldrb	r1, [r0, #1]                                 <== NOT EXECUTED
   1fb7c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
   1fb80:	e5d0c00a 	ldrb	ip, [r0, #10]                                <== NOT EXECUTED
   1fb84:	e5d0200b 	ldrb	r2, [r0, #11]                                <== NOT EXECUTED
   1fb88:	e182240c 	orr	r2, r2, ip, lsl #8                            <== NOT EXECUTED
   1fb8c:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
 * @return uint32_t The block count.                                  
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)      
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->block_count);             
   1fb90:	e280200c 	add	r2, r0, #12                                   <== NOT EXECUTED
   1fb94:	e5d2c003 	ldrb	ip, [r2, #3]                                 <== NOT EXECUTED
   1fb98:	e5d0600c 	ldrb	r6, [r0, #12]                                <== NOT EXECUTED
   1fb9c:	e5d20001 	ldrb	r0, [r2, #1]                                 <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   1fba0:	e181140e 	orr	r1, r1, lr, lsl #8                            <== NOT EXECUTED
   1fba4:	e5d22002 	ldrb	r2, [r2, #2]                                 <== NOT EXECUTED
   1fba8:	e18c6c06 	orr	r6, ip, r6, lsl #24                           <== NOT EXECUTED
   1fbac:	e186c800 	orr	ip, r6, r0, lsl #16                           <== NOT EXECUTED
   1fbb0:	e151000b 	cmp	r1, fp                                        <== NOT EXECUTED
   1fbb4:	e18cc402 	orr	ip, ip, r2, lsl #8                            <== NOT EXECUTED
   1fbb8:	03a01000 	moveq	r1, #0                                      <== NOT EXECUTED
   1fbbc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   1fbc0:	e59f0100 	ldr	r0, [pc, #256]	; 1fcc8 <rtems_rfs_shell_inode+0x424><== NOT EXECUTED
   1fbc4:	e58dc008 	str	ip, [sp, #8]                                  <== NOT EXECUTED
   1fbc8:	eb00862a 	bl	41478 <printf>                                 <== NOT EXECUTED
   1fbcc:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
 * @return uint32_t The block number.                                 
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block) 
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);      
   1fbd0:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   1fbd4:	e282201c 	add	r2, r2, #28                                   <== NOT EXECUTED
                  rtems_rfs_inode_get_links (&inode),                 
                  mode, type, mode & ((1 << 10) - 1),                 
                  rtems_rfs_inode_get_block_offset (&inode),          
                  rtems_rfs_inode_get_block_count (&inode));          
          for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)          
            printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
   1fbd8:	e0823005 	add	r3, r2, r5                                    <== NOT EXECUTED
   1fbdc:	e7d21005 	ldrb	r1, [r2, r5]                                 <== NOT EXECUTED
   1fbe0:	e5d32003 	ldrb	r2, [r3, #3]                                 <== NOT EXECUTED
   1fbe4:	e5d30001 	ldrb	r0, [r3, #1]                                 <== NOT EXECUTED
   1fbe8:	e1822c01 	orr	r2, r2, r1, lsl #24                           <== NOT EXECUTED
   1fbec:	e5d31002 	ldrb	r1, [r3, #2]                                 <== NOT EXECUTED
   1fbf0:	e1823800 	orr	r3, r2, r0, lsl #16                           <== NOT EXECUTED
   1fbf4:	e1831401 	orr	r1, r3, r1, lsl #8                            <== NOT EXECUTED
   1fbf8:	e2855004 	add	r5, r5, #4                                    <== NOT EXECUTED
   1fbfc:	e59f00c8 	ldr	r0, [pc, #200]	; 1fccc <rtems_rfs_shell_inode+0x428><== NOT EXECUTED
   1fc00:	eb00861c 	bl	41478 <printf>                                 <== NOT EXECUTED
          printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
                  rtems_rfs_inode_get_links (&inode),                 
                  mode, type, mode & ((1 << 10) - 1),                 
                  rtems_rfs_inode_get_block_offset (&inode),          
                  rtems_rfs_inode_get_block_count (&inode));          
          for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)          
   1fc04:	e3550010 	cmp	r5, #16                                       <== NOT EXECUTED
   1fc08:	1afffff0 	bne	1fbd0 <rtems_rfs_shell_inode+0x32c>           <== NOT EXECUTED
   1fc0c:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
   1fc10:	e283301c 	add	r3, r3, #28                                   <== NOT EXECUTED
            printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
          printf ("%" PRIu32 "]\n", rtems_rfs_inode_get_block (&inode, b));
   1fc14:	e5d30011 	ldrb	r0, [r3, #17]                                <== NOT EXECUTED
   1fc18:	e5d31010 	ldrb	r1, [r3, #16]                                <== NOT EXECUTED
   1fc1c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
   1fc20:	e5d32013 	ldrb	r2, [r3, #19]                                <== NOT EXECUTED
   1fc24:	e1800c01 	orr	r0, r0, r1, lsl #24                           <== NOT EXECUTED
   1fc28:	e5d31012 	ldrb	r1, [r3, #18]                                <== NOT EXECUTED
   1fc2c:	e1803002 	orr	r3, r0, r2                                    <== NOT EXECUTED
   1fc30:	e1831401 	orr	r1, r3, r1, lsl #8                            <== NOT EXECUTED
   1fc34:	e59f0094 	ldr	r0, [pc, #148]	; 1fcd0 <rtems_rfs_shell_inode+0x42c><== NOT EXECUTED
   1fc38:	eb00860e 	bl	41478 <printf>                                 <== NOT EXECUTED
        }                                                             
      }                                                               
                                                                      
      rc = rtems_rfs_inode_close (fs, &inode);                        
   1fc3c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fc40:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   1fc44:	eb005f2b 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      if (rc > 0)                                                     
   1fc48:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
   1fc4c:	da000008 	ble	1fc74 <rtems_rfs_shell_inode+0x3d0>           <== NOT EXECUTED
      {                                                               
        rtems_rfs_shell_unlock_rfs (fs);                              
   1fc50:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fc54:	ebffff0c 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
        printf ("error: closing inode handle: ino=%" PRIu32 ": (%d) %s\n",
   1fc58:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   1fc5c:	eb008e18 	bl	434c4 <strerror>                               <== NOT EXECUTED
   1fc60:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   1fc64:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   1fc68:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   1fc6c:	e59f0060 	ldr	r0, [pc, #96]	; 1fcd4 <rtems_rfs_shell_inode+0x430><== NOT EXECUTED
   1fc70:	eaffff6b 	b	1fa24 <rtems_rfs_shell_inode+0x180>             <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  rtems_rfs_shell_lock_rfs (fs);                                      
                                                                      
  for (ino = start; ino <= end; ino++)                                
   1fc74:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
   1fc78:	e1590008 	cmp	r9, r8                                        <== NOT EXECUTED
   1fc7c:	9affff59 	bls	1f9e8 <rtems_rfs_shell_inode+0x144>           <== NOT EXECUTED
        return 1;                                                     
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_shell_unlock_rfs (fs);                                    
   1fc80:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   1fc84:	ebffff00 	bl	1f88c <rtems_rfs_shell_unlock_rfs>             <== NOT EXECUTED
   1fc88:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
   1fc8c:	e28dd04c 	add	sp, sp, #76	; 0x4c                            <== NOT EXECUTED
   1fc90:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0001f88c <rtems_rfs_shell_unlock_rfs>: /** * Unlock the file system. */ static void rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs) {
   1f88c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
 * Unlock the RFS file system.                                        
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)                   
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
   1f890:	e590407c 	ldr	r4, [r0, #124]	; 0x7c                         <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
   1f894:	eb0052f7 	bl	34478 <rtems_rfs_buffers_release>              <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
   1f898:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
#if __rtems__                                                         
  rtems_rfs_rtems_unlock (fs);                                        
#endif                                                                
}                                                                     
   1f89c:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
   1f8a0:	eaffb04c 	b	b9d8 <rtems_semaphore_release>                  <== NOT EXECUTED
                                                                      

0001f650 <rtems_rfs_shell_usage>: } void rtems_rfs_shell_usage (const char* arg) {
   1f650:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  printf ("%s: RFS debugger\n", arg);                                 
   1f654:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
}                                                                     
                                                                      
                                                                      
void                                                                  
rtems_rfs_shell_usage (const char* arg)                               
{                                                                     
   1f658:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  printf ("%s: RFS debugger\n", arg);                                 
   1f65c:	e59f0038 	ldr	r0, [pc, #56]	; 1f69c <rtems_rfs_shell_usage+0x4c><== NOT EXECUTED
   1f660:	eb008784 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("  %s [-hl] <path> <command>\n", arg);                      
   1f664:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   1f668:	e59f0030 	ldr	r0, [pc, #48]	; 1f6a0 <rtems_rfs_shell_usage+0x50><== NOT EXECUTED
   1f66c:	eb008781 	bl	41478 <printf>                                 <== NOT EXECUTED
  printf ("   where:\n");                                             
   1f670:	e59f002c 	ldr	r0, [pc, #44]	; 1f6a4 <rtems_rfs_shell_usage+0x54><== NOT EXECUTED
   1f674:	eb008824 	bl	4170c <puts>                                   <== NOT EXECUTED
  printf ("     path:    Path to the mounted RFS file system\n");     
   1f678:	e59f0028 	ldr	r0, [pc, #40]	; 1f6a8 <rtems_rfs_shell_usage+0x58><== NOT EXECUTED
   1f67c:	eb008822 	bl	4170c <puts>                                   <== NOT EXECUTED
  printf ("     command: A debugger command. See -l for a list plus help.\n");
   1f680:	e59f0024 	ldr	r0, [pc, #36]	; 1f6ac <rtems_rfs_shell_usage+0x5c><== NOT EXECUTED
   1f684:	eb008820 	bl	4170c <puts>                                   <== NOT EXECUTED
  printf ("     -h:      This help\n");                               
   1f688:	e59f0020 	ldr	r0, [pc, #32]	; 1f6b0 <rtems_rfs_shell_usage+0x60><== NOT EXECUTED
   1f68c:	eb00881e 	bl	4170c <puts>                                   <== NOT EXECUTED
  printf ("     -l:      The debugger command list.\n");              
   1f690:	e59f001c 	ldr	r0, [pc, #28]	; 1f6b4 <rtems_rfs_shell_usage+0x64><== NOT EXECUTED
}                                                                     
   1f694:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
  printf ("  %s [-hl] <path> <command>\n", arg);                      
  printf ("   where:\n");                                             
  printf ("     path:    Path to the mounted RFS file system\n");     
  printf ("     command: A debugger command. See -l for a list plus help.\n");
  printf ("     -h:      This help\n");                               
  printf ("     -l:      The debugger command list.\n");              
   1f698:	ea00881b 	b	4170c <puts>                                    <== NOT EXECUTED
                                                                      

00037f0c <rtems_rfs_symlink>: const char* link, int link_length, uid_t uid, gid_t gid, rtems_rfs_ino parent) {
   37f0c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   37f10:	e24dd0a0 	sub	sp, sp, #160	; 0xa0                           <== NOT EXECUTED
   37f14:	e59d80c4 	ldr	r8, [sp, #196]	; 0xc4                         <== NOT EXECUTED
    printf (" link:");                                                
    for (c = 0; c < link_length; c++)                                 
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
   37f18:	e5902008 	ldr	r2, [r0, #8]                                  <== NOT EXECUTED
   37f1c:	e1580002 	cmp	r8, r2                                        <== NOT EXECUTED
                   const char*            link,                       
                   int                    link_length,                
                   uid_t                  uid,                        
                   gid_t                  gid,                        
                   rtems_rfs_ino          parent)                     
{                                                                     
   37f20:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   37f24:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   37f28:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
   37f2c:	e1dd6cb8 	ldrh	r6, [sp, #200]	; 0xc8                        <== NOT EXECUTED
   37f30:	e1dd7cbc 	ldrh	r7, [sp, #204]	; 0xcc                        <== NOT EXECUTED
    printf (" link:");                                                
    for (c = 0; c < link_length; c++)                                 
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
   37f34:	23a0a05b 	movcs	sl, #91	; 0x5b                              <== NOT EXECUTED
   37f38:	2a00006f 	bcs	380fc <rtems_rfs_symlink+0x1f0>               <== NOT EXECUTED
    return ENAMETOOLONG;                                              
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),       
   37f3c:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
   37f40:	eb002eeb 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   37f44:	e59fc1bc 	ldr	ip, [pc, #444]	; 38108 <rtems_rfs_symlink+0x1fc><== NOT EXECUTED
   37f48:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   37f4c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   37f50:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37f54:	e59d10d0 	ldr	r1, [sp, #208]	; 0xd0                         <== NOT EXECUTED
   37f58:	e28dc09c 	add	ip, sp, #156	; 0x9c                           <== NOT EXECUTED
   37f5c:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
   37f60:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37f64:	e98d10e0 	stmib	sp, {r5, r6, r7, ip}                        <== NOT EXECUTED
   37f68:	ebfffee7 	bl	37b0c <rtems_rfs_inode_create>                 <== NOT EXECUTED
                               RTEMS_RFS_S_SYMLINK,                   
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
   37f6c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   37f70:	ca000061 	bgt	380fc <rtems_rfs_symlink+0x1f0>               <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
   37f74:	e28d6064 	add	r6, sp, #100	; 0x64                           <== NOT EXECUTED
   37f78:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37f7c:	e59d109c 	ldr	r1, [sp, #156]	; 0x9c                         <== NOT EXECUTED
   37f80:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
   37f84:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   37f88:	ebfffe7d 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc > 0)                                                         
   37f8c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   37f90:	ca000059 	bgt	380fc <rtems_rfs_symlink+0x1f0>               <== NOT EXECUTED
  /*                                                                  
   * If the link length is less than the length of data union in the inode
   * place the link into the data area else allocate a block and write the link
   * to that.                                                         
   */                                                                 
  if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)                   
   37f94:	e3580013 	cmp	r8, #19                                       <== NOT EXECUTED
   37f98:	8a000013 	bhi	37fec <rtems_rfs_symlink+0xe0>                <== NOT EXECUTED
  {                                                                   
    memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
   37f9c:	e59d0070 	ldr	r0, [sp, #112]	; 0x70                         <== NOT EXECUTED
   37fa0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   37fa4:	e3a02014 	mov	r2, #20                                       <== NOT EXECUTED
   37fa8:	e280001c 	add	r0, r0, #28                                   <== NOT EXECUTED
   37fac:	eb00210a 	bl	403dc <memset>                                 <== NOT EXECUTED
    memcpy (inode.node->data.name, link, link_length);                
   37fb0:	e59d0070 	ldr	r0, [sp, #112]	; 0x70                         <== NOT EXECUTED
   37fb4:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   37fb8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   37fbc:	e280001c 	add	r0, r0, #28                                   <== NOT EXECUTED
   37fc0:	eb00207e 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
 * @param block_count The block count.                                
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{                                                                     
  rtems_rfs_write_u32 (&handle->node->block_count, block_count);      
   37fc4:	e59d2070 	ldr	r2, [sp, #112]	; 0x70                         <== NOT EXECUTED
   37fc8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   37fcc:	e5c2300c 	strb	r3, [r2, #12]                                <== NOT EXECUTED
   37fd0:	e59d2070 	ldr	r2, [sp, #112]	; 0x70                         <== NOT EXECUTED
   37fd4:	e5c2300d 	strb	r3, [r2, #13]                                <== NOT EXECUTED
   37fd8:	e59d2070 	ldr	r2, [sp, #112]	; 0x70                         <== NOT EXECUTED
   37fdc:	e5c2300e 	strb	r3, [r2, #14]                                <== NOT EXECUTED
   37fe0:	e59d2070 	ldr	r2, [sp, #112]	; 0x70                         <== NOT EXECUTED
   37fe4:	e5c2300f 	strb	r3, [r2, #15]                                <== NOT EXECUTED
   37fe8:	ea000036 	b	380c8 <rtems_rfs_symlink+0x1bc>                 <== NOT EXECUTED
    rtems_rfs_block_map     map;                                      
    rtems_rfs_block_no      block;                                    
    rtems_rfs_buffer_handle buffer;                                   
    uint8_t*                data;                                     
                                                                      
    rc = rtems_rfs_block_map_open (fs, &inode, &map);                 
   37fec:	e28d7014 	add	r7, sp, #20                                   <== NOT EXECUTED
   37ff0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37ff4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   37ff8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   37ffc:	ebfff0a7 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
    if (rc > 0)                                                       
   38000:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   38004:	ca00002b 	bgt	380b8 <rtems_rfs_symlink+0x1ac>               <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);              
   38008:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   3800c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38010:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   38014:	e28d3098 	add	r3, sp, #152	; 0x98                           <== NOT EXECUTED
   38018:	ebffef42 	bl	33d28 <rtems_rfs_block_map_grow>               <== NOT EXECUTED
    if (rc > 0)                                                       
   3801c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   38020:	ca00000b 	bgt	38054 <rtems_rfs_symlink+0x148>               <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   38024:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false); 
   38028:	e28d908c 	add	r9, sp, #140	; 0x8c                           <== NOT EXECUTED
   3802c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38030:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   38034:	e59d2098 	ldr	r2, [sp, #152]	; 0x98                         <== NOT EXECUTED
   38038:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   3803c:	e5cd508c 	strb	r5, [sp, #140]	; 0x8c                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   38040:	e58d5090 	str	r5, [sp, #144]	; 0x90                         <== NOT EXECUTED
  handle->buffer = NULL;                                              
   38044:	e58d5094 	str	r5, [sp, #148]	; 0x94                         <== NOT EXECUTED
   38048:	ebfff1a4 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
    if (rc > 0)                                                       
   3804c:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   38050:	da000003 	ble	38064 <rtems_rfs_symlink+0x158>               <== NOT EXECUTED
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
   38054:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   38058:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   3805c:	ebfff01d 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
   38060:	ea000014 	b	380b8 <rtems_rfs_symlink+0x1ac>                 <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    data = rtems_rfs_buffer_data (&buffer);                           
   38064:	e59d3094 	ldr	r3, [sp, #148]	; 0x94                         <== NOT EXECUTED
   38068:	e593a020 	ldr	sl, [r3, #32]                                 <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
   3806c:	e3a010ff 	mov	r1, #255	; 0xff                               <== NOT EXECUTED
   38070:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   38074:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
   38078:	eb0020d7 	bl	403dc <memset>                                 <== NOT EXECUTED
    memcpy (data, link, link_length);                                 
   3807c:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
   38080:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   38084:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
   38088:	eb00204c 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   3808c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
   38090:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38094:	ebfff148 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_close (fs, &map);                        
   38098:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   3809c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   380a0:	e58d5094 	str	r5, [sp, #148]	; 0x94                         <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   380a4:	e5cd508c 	strb	r5, [sp, #140]	; 0x8c                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   380a8:	e58d5090 	str	r5, [sp, #144]	; 0x90                         <== NOT EXECUTED
   380ac:	ebfff009 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
    if (rc > 0)                                                       
   380b0:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
   380b4:	da000003 	ble	380c8 <rtems_rfs_symlink+0x1bc>               <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
   380b8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   380bc:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
   380c0:	ebfffe0c 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      return rc;                                                      
   380c4:	ea00000c 	b	380fc <rtems_rfs_symlink+0x1f0>                 <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,     
                                  uint16_t                block_offset)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);    
   380c8:	e59d3070 	ldr	r3, [sp, #112]	; 0x70                         <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_inode_set_block_offset (&inode, link_length);             
   380cc:	e1a08808 	lsl	r8, r8, #16                                   <== NOT EXECUTED
   380d0:	e1a02c28 	lsr	r2, r8, #24                                   <== NOT EXECUTED
   380d4:	e5c3200a 	strb	r2, [r3, #10]                                <== NOT EXECUTED
   380d8:	e59d3070 	ldr	r3, [sp, #112]	; 0x70                         <== NOT EXECUTED
   380dc:	e1a08828 	lsr	r8, r8, #16                                   <== NOT EXECUTED
   380e0:	e5c3800b 	strb	r8, [r3, #11]                                <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   380e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   380e8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   380ec:	e28d1064 	add	r1, sp, #100	; 0x64                           <== NOT EXECUTED
   380f0:	e5cd3074 	strb	r3, [sp, #116]	; 0x74                        <== NOT EXECUTED
   380f4:	ebfffdff 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   380f8:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
   380fc:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
   38100:	e28dd0a0 	add	sp, sp, #160	; 0xa0                           <== NOT EXECUTED
   38104:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00037d6c <rtems_rfs_symlink_read>: rtems_rfs_symlink_read (rtems_rfs_file_system* fs, rtems_rfs_ino link, char* path, size_t size, size_t* length) {
   37d6c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   37d70:	e24dd08c 	sub	sp, sp, #140	; 0x8c                           <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);     
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
   37d74:	e28d5054 	add	r5, sp, #84	; 0x54                            <== NOT EXECUTED
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,                    
                        rtems_rfs_ino          link,                  
                        char*                  path,                  
                        size_t                 size,                  
                        size_t*                length)                
{                                                                     
   37d78:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
   37d7c:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);     
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
   37d80:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   37d84:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,                    
                        rtems_rfs_ino          link,                  
                        char*                  path,                  
                        size_t                 size,                  
                        size_t*                length)                
{                                                                     
   37d88:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   37d8c:	e59d90b0 	ldr	r9, [sp, #176]	; 0xb0                         <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);     
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
   37d90:	ebfffefb 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   37d94:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   37d98:	1a000058 	bne	37f00 <rtems_rfs_symlink_read+0x194>          <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   37d9c:	e59d1060 	ldr	r1, [sp, #96]	; 0x60                          <== NOT EXECUTED
    return rc;                                                        
                                                                      
  if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))         
   37da0:	e5d13002 	ldrb	r3, [r1, #2]                                 <== NOT EXECUTED
   37da4:	e1a03403 	lsl	r3, r3, #8                                    <== NOT EXECUTED
   37da8:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
   37dac:	e3530a0a 	cmp	r3, #40960	; 0xa000                           <== NOT EXECUTED
   37db0:	1a000005 	bne	37dcc <rtems_rfs_symlink_read+0x60>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
    return EINVAL;                                                    
  }                                                                   
                                                                      
  *length = rtems_rfs_inode_get_block_offset (&inode);                
   37db4:	e5d1200a 	ldrb	r2, [r1, #10]                                <== NOT EXECUTED
   37db8:	e5d1300b 	ldrb	r3, [r1, #11]                                <== NOT EXECUTED
   37dbc:	e1832402 	orr	r2, r3, r2, lsl #8                            <== NOT EXECUTED
                                                                      
  if (size < *length)                                                 
   37dc0:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
    return EINVAL;                                                    
  }                                                                   
                                                                      
  *length = rtems_rfs_inode_get_block_offset (&inode);                
   37dc4:	e5892000 	str	r2, [r9]                                      <== NOT EXECUTED
                                                                      
  if (size < *length)                                                 
   37dc8:	2a000004 	bcs	37de0 <rtems_rfs_symlink_read+0x74>           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
   37dcc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37dd0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37dd4:	ebfffec7 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   37dd8:	e3a0b016 	mov	fp, #22                                       <== NOT EXECUTED
    return EINVAL;                                                    
   37ddc:	ea000047 	b	37f00 <rtems_rfs_symlink_read+0x194>            <== NOT EXECUTED
 * @return uint32_t The block count.                                  
 */                                                                   
static inline uint32_t                                                
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)      
{                                                                     
  return rtems_rfs_read_u32 (&handle->node->block_count);             
   37de0:	e281300c 	add	r3, r1, #12                                   <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_inode_get_block_count (&inode) == 0)                  
   37de4:	e5d30003 	ldrb	r0, [r3, #3]                                 <== NOT EXECUTED
   37de8:	e5d1c00c 	ldrb	ip, [r1, #12]                                <== NOT EXECUTED
   37dec:	e5d3e001 	ldrb	lr, [r3, #1]                                 <== NOT EXECUTED
   37df0:	e180cc0c 	orr	ip, r0, ip, lsl #24                           <== NOT EXECUTED
   37df4:	e5d30002 	ldrb	r0, [r3, #2]                                 <== NOT EXECUTED
   37df8:	e18c380e 	orr	r3, ip, lr, lsl #16                           <== NOT EXECUTED
   37dfc:	e1930400 	orrs	r0, r3, r0, lsl #8                           <== NOT EXECUTED
   37e00:	1a000003 	bne	37e14 <rtems_rfs_symlink_read+0xa8>           <== NOT EXECUTED
  {                                                                   
    memcpy (path, inode.node->data.name, *length);                    
   37e04:	e281101c 	add	r1, r1, #28                                   <== NOT EXECUTED
   37e08:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   37e0c:	eb0020eb 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
   37e10:	ea000033 	b	37ee4 <rtems_rfs_symlink_read+0x178>            <== NOT EXECUTED
    rtems_rfs_block_map     map;                                      
    rtems_rfs_block_no      block;                                    
    rtems_rfs_buffer_handle buffer;                                   
    char*                   data;                                     
                                                                      
    rc = rtems_rfs_block_map_open (fs, &inode, &map);                 
   37e14:	e28d7004 	add	r7, sp, #4                                    <== NOT EXECUTED
   37e18:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37e1c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37e20:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   37e24:	ebfff11d 	bl	342a0 <rtems_rfs_block_map_open>               <== NOT EXECUTED
    if (rc > 0)                                                       
   37e28:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   37e2c:	ca000028 	bgt	37ed4 <rtems_rfs_symlink_read+0x168>          <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);              
   37e30:	e28dc088 	add	ip, sp, #136	; 0x88                           <== NOT EXECUTED
   37e34:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37e38:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37e3c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   37e40:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   37e44:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   37e48:	ebffee7a 	bl	33838 <rtems_rfs_block_map_seek>               <== NOT EXECUTED
    if (rc > 0)                                                       
   37e4c:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   37e50:	ca00000b 	bgt	37e84 <rtems_rfs_symlink_read+0x118>          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
   37e54:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false); 
   37e58:	e28da07c 	add	sl, sp, #124	; 0x7c                           <== NOT EXECUTED
   37e5c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37e60:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   37e64:	e59d2088 	ldr	r2, [sp, #136]	; 0x88                         <== NOT EXECUTED
   37e68:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   37e6c:	e5cd607c 	strb	r6, [sp, #124]	; 0x7c                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   37e70:	e58d6080 	str	r6, [sp, #128]	; 0x80                         <== NOT EXECUTED
  handle->buffer = NULL;                                              
   37e74:	e58d6084 	str	r6, [sp, #132]	; 0x84                         <== NOT EXECUTED
   37e78:	ebfff218 	bl	346e0 <rtems_rfs_buffer_handle_request>        <== NOT EXECUTED
    if (rc > 0)                                                       
   37e7c:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   37e80:	da000003 	ble	37e94 <rtems_rfs_symlink_read+0x128>          <== NOT EXECUTED
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
   37e84:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37e88:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37e8c:	ebfff091 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
   37e90:	ea00000f 	b	37ed4 <rtems_rfs_symlink_read+0x168>            <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    data = rtems_rfs_buffer_data (&buffer);                           
    memcpy (path, data, *length);                                     
   37e94:	e59d3084 	ldr	r3, [sp, #132]	; 0x84                         <== NOT EXECUTED
   37e98:	e5992000 	ldr	r2, [r9]                                      <== NOT EXECUTED
   37e9c:	e5931020 	ldr	r1, [r3, #32]                                 <== NOT EXECUTED
   37ea0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   37ea4:	eb0020c5 	bl	401c0 <memcpy>                                 <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
   37ea8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   37eac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37eb0:	ebfff1c1 	bl	345bc <rtems_rfs_buffer_handle_release>        <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_close (fs, &map);                        
   37eb4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   37eb8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
  handle->buffer = NULL;                                              
   37ebc:	e58d6084 	str	r6, [sp, #132]	; 0x84                         <== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,           
                               rtems_rfs_buffer_handle* handle)       
{                                                                     
  rtems_rfs_buffer_handle_release (fs, handle);                       
  handle->dirty = false;                                              
   37ec0:	e5cd607c 	strb	r6, [sp, #124]	; 0x7c                        <== NOT EXECUTED
  handle->bnum  = 0;                                                  
   37ec4:	e58d6080 	str	r6, [sp, #128]	; 0x80                         <== NOT EXECUTED
   37ec8:	ebfff082 	bl	340d8 <rtems_rfs_block_map_close>              <== NOT EXECUTED
    if (rc > 0)                                                       
   37ecc:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
   37ed0:	da000003 	ble	37ee4 <rtems_rfs_symlink_read+0x178>          <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
   37ed4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37ed8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   37edc:	ebfffe85 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
      return rc;                                                      
   37ee0:	ea000006 	b	37f00 <rtems_rfs_symlink_read+0x194>            <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  path[*length] = '\0';                                               
   37ee4:	e5993000 	ldr	r3, [r9]                                      <== NOT EXECUTED
   37ee8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   37eec:	e7c82003 	strb	r2, [r8, r3]                                 <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
   37ef0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   37ef4:	e28d1054 	add	r1, sp, #84	; 0x54                            <== NOT EXECUTED
   37ef8:	ebfffe7e 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   37efc:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
   37f00:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
   37f04:	e28dd08c 	add	sp, sp, #140	; 0x8c                           <== NOT EXECUTED
   37f08:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

0003810c <rtems_rfs_unlink>: rtems_rfs_unlink (rtems_rfs_file_system* fs, rtems_rfs_ino parent, rtems_rfs_ino target, uint32_t doff, rtems_rfs_unlink_dir dir_mode) {
   3810c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   38110:	e24dd050 	sub	sp, sp, #80	; 0x50                            <== NOT EXECUTED
   38114:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
   38118:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
   3811c:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
    printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
   38120:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
   38124:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38128:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
rtems_rfs_unlink (rtems_rfs_file_system* fs,                          
                  rtems_rfs_ino          parent,                      
                  rtems_rfs_ino          target,                      
                  uint32_t               doff,                        
                  rtems_rfs_unlink_dir   dir_mode)                    
{                                                                     
   3812c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   38130:	e59d8074 	ldr	r8, [sp, #116]	; 0x74                         <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
    printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
   38134:	ebfffe12 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   38138:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
    printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
   3813c:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
  if (rc)                                                             
   38140:	1a00006f 	bne	38304 <rtems_rfs_unlink+0x1f8>                <== NOT EXECUTED
 * @return uint16_t The mode.                                         
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)             
{                                                                     
  return rtems_rfs_read_u16 (&handle->node->mode);                    
   38144:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If a directory process the unlink mode.                          
   */                                                                 
                                                                      
  dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)); 
   38148:	e5d36002 	ldrb	r6, [r3, #2]                                 <== NOT EXECUTED
   3814c:	e1a06406 	lsl	r6, r6, #8                                    <== NOT EXECUTED
   38150:	e2066a0f 	and	r6, r6, #61440	; 0xf000                       <== NOT EXECUTED
   38154:	e3560901 	cmp	r6, #16384	; 0x4000                           <== NOT EXECUTED
   38158:	13a06000 	movne	r6, #0                                      <== NOT EXECUTED
   3815c:	03a06001 	moveq	r6, #1                                      <== NOT EXECUTED
  if (dir)                                                            
   38160:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   38164:	0a00000e 	beq	381a4 <rtems_rfs_unlink+0x98>                 <== NOT EXECUTED
  {                                                                   
    switch (dir_mode)                                                 
   38168:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
   3816c:	0a000002 	beq	3817c <rtems_rfs_unlink+0x70>                 <== NOT EXECUTED
   38170:	e3580001 	cmp	r8, #1                                        <== NOT EXECUTED
   38174:	1a00000a 	bne	381a4 <rtems_rfs_unlink+0x98>                 <== NOT EXECUTED
   38178:	ea000004 	b	38190 <rtems_rfs_unlink+0x84>                   <== NOT EXECUTED
    {                                                                 
      case rtems_rfs_unlink_dir_denied:                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                 
          printf ("rtems-rfs: link is a directory\n");                
        rtems_rfs_inode_close (fs, &target_inode);                    
   3817c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38180:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   38184:	ebfffddb 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   38188:	e3a09015 	mov	r9, #21                                       <== NOT EXECUTED
        return EISDIR;                                                
   3818c:	ea00005c 	b	38304 <rtems_rfs_unlink+0x1f8>                  <== NOT EXECUTED
                                                                      
      case rtems_rfs_unlink_dir_if_empty:                             
        rc = rtems_rfs_dir_empty (fs, &target_inode);                 
   38190:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38194:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   38198:	ebfff1da 	bl	34908 <rtems_rfs_dir_empty>                    <== NOT EXECUTED
        if (rc > 0)                                                   
   3819c:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   381a0:	ca000047 	bgt	382c4 <rtems_rfs_unlink+0x1b8>                <== NOT EXECUTED
      default:                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
   381a4:	e28d5028 	add	r5, sp, #40	; 0x28                            <== NOT EXECUTED
   381a8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
   381ac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   381b0:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   381b4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   381b8:	ebfffdf1 	bl	37984 <rtems_rfs_inode_open>                   <== NOT EXECUTED
  if (rc)                                                             
   381bc:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   381c0:	1a00003f 	bne	382c4 <rtems_rfs_unlink+0x1b8>                <== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);     
   381c4:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
   381c8:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
   381cc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   381d0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   381d4:	ebfff2d8 	bl	34d3c <rtems_rfs_dir_del_entry>                <== NOT EXECUTED
  if (rc > 0)                                                         
   381d8:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   381dc:	ca000035 	bgt	382b8 <rtems_rfs_unlink+0x1ac>                <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   381e0:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   381e4:	e5d31000 	ldrb	r1, [r3]                                     <== NOT EXECUTED
   381e8:	e5d32001 	ldrb	r2, [r3, #1]                                 <== NOT EXECUTED
   381ec:	e1822401 	orr	r2, r2, r1, lsl #8                            <== NOT EXECUTED
  if (links == 0xffff)                                                
   381f0:	e59f1118 	ldr	r1, [pc, #280]	; 38310 <rtems_rfs_unlink+0x204><== NOT EXECUTED
   381f4:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
   381f8:	0a00000b 	beq	3822c <rtems_rfs_unlink+0x120>                <== NOT EXECUTED
  links = rtems_rfs_inode_get_links (&target_inode);                  
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
    printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
                                                                      
  if (links > 1)                                                      
   381fc:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
   38200:	9a000009 	bls	3822c <rtems_rfs_unlink+0x120>                <== NOT EXECUTED
  {                                                                   
    links--;                                                          
   38204:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
   38208:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
 * @prarm links The links.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
   3820c:	e1a01c22 	lsr	r1, r2, #24                                   <== NOT EXECUTED
   38210:	e5c31000 	strb	r1, [r3]                                     <== NOT EXECUTED
   38214:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
   38218:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
   3821c:	e5c32001 	strb	r2, [r3, #1]                                 <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   38220:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38224:	e5cd3010 	strb	r3, [sp, #16]                                <== NOT EXECUTED
   38228:	ea00001b 	b	3829c <rtems_rfs_unlink+0x190>                  <== NOT EXECUTED
  else                                                                
  {                                                                   
    /*                                                                
     * Erasing the inode releases all blocks attached to it.          
     */                                                               
    rc = rtems_rfs_inode_delete (fs, &target_inode);                  
   3822c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   38230:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   38234:	ebfffe05 	bl	37a50 <rtems_rfs_inode_delete>                 <== NOT EXECUTED
    if (rc > 0)                                                       
   38238:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
  else                                                                
  {                                                                   
    /*                                                                
     * Erasing the inode releases all blocks attached to it.          
     */                                                               
    rc = rtems_rfs_inode_delete (fs, &target_inode);                  
   3823c:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
    if (rc > 0)                                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                   
        printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",      
                rc, strerror (rc));                                   
      rtems_rfs_inode_close (fs, &parent_inode);                      
   38240:	c1a00004 	movgt	r0, r4                                      <== NOT EXECUTED
   38244:	c28d1028 	addgt	r1, sp, #40	; 0x28                          <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Erasing the inode releases all blocks attached to it.          
     */                                                               
    rc = rtems_rfs_inode_delete (fs, &target_inode);                  
    if (rc > 0)                                                       
   38248:	ca00001c 	bgt	382c0 <rtems_rfs_unlink+0x1b4>                <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &parent_inode);                      
      rtems_rfs_inode_close (fs, &target_inode);                      
      return rc;                                                      
    }                                                                 
                                                                      
    if (dir)                                                          
   3824c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
   38250:	0a000011 	beq	3829c <rtems_rfs_unlink+0x190>                <== NOT EXECUTED
 */                                                                   
static inline uint16_t                                                
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)            
{                                                                     
  uint16_t links;                                                     
  links = rtems_rfs_read_u16 (&handle->node->links);                  
   38254:	e59d2034 	ldr	r2, [sp, #52]	; 0x34                          <== NOT EXECUTED
   38258:	e5d21000 	ldrb	r1, [r2]                                     <== NOT EXECUTED
   3825c:	e5d23001 	ldrb	r3, [r2, #1]                                 <== NOT EXECUTED
   38260:	e1833401 	orr	r3, r3, r1, lsl #8                            <== NOT EXECUTED
  if (links == 0xffff)                                                
   38264:	e59f10a4 	ldr	r1, [pc, #164]	; 38310 <rtems_rfs_unlink+0x204><== NOT EXECUTED
   38268:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
   3826c:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
   38270:	0a000003 	beq	38284 <rtems_rfs_unlink+0x178>                <== NOT EXECUTED
    {                                                                 
      links = rtems_rfs_inode_get_links (&parent_inode);              
      if (links > 1)                                                  
   38274:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
        links--;                                                      
   38278:	82433001 	subhi	r3, r3, #1                                  <== NOT EXECUTED
   3827c:	81a03803 	lslhi	r3, r3, #16                                 <== NOT EXECUTED
   38280:	81a03823 	lsrhi	r3, r3, #16                                 <== NOT EXECUTED
 * @prarm links The links.                                            
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->links, links);                  
   38284:	e1a01423 	lsr	r1, r3, #8                                    <== NOT EXECUTED
   38288:	e5c21000 	strb	r1, [r2]                                     <== NOT EXECUTED
   3828c:	e59d2034 	ldr	r2, [sp, #52]	; 0x34                          <== NOT EXECUTED
   38290:	e5c23001 	strb	r3, [r2, #1]                                 <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
   38294:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   38298:	e5cd3038 	strb	r3, [sp, #56]	; 0x38                         <== NOT EXECUTED
      rtems_rfs_inode_set_links (&parent_inode, links);               
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
   3829c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
   382a0:	e28d5028 	add	r5, sp, #40	; 0x28                            <== NOT EXECUTED
   382a4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   382a8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   382ac:	ebfffce0 	bl	37634 <rtems_rfs_inode_time_stamp_now>         <== NOT EXECUTED
  if (rc > 0)                                                         
   382b0:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   382b4:	da000005 	ble	382d0 <rtems_rfs_unlink+0x1c4>                <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
      printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",   
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &parent_inode);                        
   382b8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   382bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   382c0:	ebfffd8c 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
   382c4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   382c8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   382cc:	ea000006 	b	382ec <rtems_rfs_unlink+0x1e0>                  <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
   382d0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   382d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   382d8:	ebfffd86 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
  if (rc > 0)                                                         
   382dc:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
   382e0:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   382e4:	da000002 	ble	382f4 <rtems_rfs_unlink+0x1e8>                <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
      printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n", 
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
   382e8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   382ec:	ebfffd81 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
    return rc;                                                        
   382f0:	ea000003 	b	38304 <rtems_rfs_unlink+0x1f8>                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
   382f4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   382f8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   382fc:	ebfffd7d 	bl	378f8 <rtems_rfs_inode_close>                  <== NOT EXECUTED
   38300:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))           
    printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",   
            rc, strerror (rc));                                       
                                                                      
  return rc;                                                          
}                                                                     
   38304:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
   38308:	e28dd050 	add	sp, sp, #80	; 0x50                            <== NOT EXECUTED
   3830c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

000204c0 <rtems_shell_debugrfs>: printf (" -l: The debugger command list.\n"); } int rtems_shell_debugrfs (int argc, char *argv[]) {
   204c0:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
      "Display a block as a table for directory entrie, dir <bno>" }, 
    { "group", rtems_rfs_shell_group,                                 
      "Display the group data of a file system, group, group <group>, group <start> <end>" },
    { "inode", rtems_rfs_shell_inode,                                 
      "Display an inode, inode <ino>, inode> <ino>..<ino>" }          
  };                                                                  
   204c4:	e59fe20c 	ldr	lr, [pc, #524]	; 206d8 <rtems_shell_debugrfs+0x218><== NOT EXECUTED
  printf ("     -l:      The debugger command list.\n");              
}                                                                     
                                                                      
int                                                                   
rtems_shell_debugrfs (int argc, char *argv[])                         
{                                                                     
   204c8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   204cc:	e24dd08c 	sub	sp, sp, #140	; 0x8c                           <== NOT EXECUTED
   204d0:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
      "Display a block as a table for directory entrie, dir <bno>" }, 
    { "group", rtems_rfs_shell_group,                                 
      "Display the group data of a file system, group, group <group>, group <start> <end>" },
    { "inode", rtems_rfs_shell_inode,                                 
      "Display an inode, inode <ino>, inode> <ino>..<ino>" }          
  };                                                                  
   204d4:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   204d8:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
   204dc:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   204e0:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   204e4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   204e8:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   204ec:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
   204f0:	e89e0007 	ldm	lr, {r0, r1, r2}                              <== NOT EXECUTED
                                                                      
  int arg;                                                            
  int t;                                                              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
   204f4:	e3550001 	cmp	r5, #1                                        <== NOT EXECUTED
      "Display a block as a table for directory entrie, dir <bno>" }, 
    { "group", rtems_rfs_shell_group,                                 
      "Display the group data of a file system, group, group <group>, group <start> <end>" },
    { "inode", rtems_rfs_shell_inode,                                 
      "Display an inode, inode <ino>, inode> <ino>..<ino>" }          
  };                                                                  
   204f8:	e88c0007 	stm	ip, {r0, r1, r2}                              <== NOT EXECUTED
                                                                      
  int arg;                                                            
  int t;                                                              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
   204fc:	da000029 	ble	205a8 <rtems_shell_debugrfs+0xe8>             <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] != '-')                                          
   20500:	e5947004 	ldr	r7, [r4, #4]                                  <== NOT EXECUTED
   20504:	e5d73000 	ldrb	r3, [r7]                                     <== NOT EXECUTED
   20508:	e353002d 	cmp	r3, #45	; 0x2d                                <== NOT EXECUTED
   2050c:	1a000023 	bne	205a0 <rtems_shell_debugrfs+0xe0>             <== NOT EXECUTED
      break;                                                          
                                                                      
    switch (argv[arg][1])                                             
   20510:	e5d73001 	ldrb	r3, [r7, #1]                                 <== NOT EXECUTED
   20514:	e3530068 	cmp	r3, #104	; 0x68                               <== NOT EXECUTED
   20518:	0a000004 	beq	20530 <rtems_shell_debugrfs+0x70>             <== NOT EXECUTED
   2051c:	e353006c 	cmp	r3, #108	; 0x6c                               <== NOT EXECUTED
        printf ("%s: commands are:\n", argv[0]);                      
        for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
          printf ("  %s\t\t%s\n", table[t].name, table[t].help);      
        return 0;                                                     
      default:                                                        
        printf ("error: unknown option: %s\n", argv[arg]);            
   20520:	11a01007 	movne	r1, r7                                      <== NOT EXECUTED
   20524:	159f01b0 	ldrne	r0, [pc, #432]	; 206dc <rtems_shell_debugrfs+0x21c><== NOT EXECUTED
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] != '-')                                          
      break;                                                          
                                                                      
    switch (argv[arg][1])                                             
   20528:	1a000066 	bne	206c8 <rtems_shell_debugrfs+0x208>            <== NOT EXECUTED
   2052c:	ea000002 	b	2053c <rtems_shell_debugrfs+0x7c>               <== NOT EXECUTED
    {                                                                 
      case 'h':                                                       
        rtems_rfs_shell_usage (argv[0]);                              
   20530:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   20534:	ebfffc45 	bl	1f650 <rtems_rfs_shell_usage>                  <== NOT EXECUTED
   20538:	ea000016 	b	20598 <rtems_shell_debugrfs+0xd8>               <== NOT EXECUTED
        return 0;                                                     
      case 'l':                                                       
        printf ("%s: commands are:\n", argv[0]);                      
   2053c:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
   20540:	e59f0198 	ldr	r0, [pc, #408]	; 206e0 <rtems_shell_debugrfs+0x220><== NOT EXECUTED
   20544:	eb0083cb 	bl	41478 <printf>                                 <== NOT EXECUTED
        for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
          printf ("  %s\t\t%s\n", table[t].name, table[t].help);      
   20548:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
   2054c:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
   20550:	e59f018c 	ldr	r0, [pc, #396]	; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
   20554:	eb0083c7 	bl	41478 <printf>                                 <== NOT EXECUTED
   20558:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
   2055c:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
   20560:	e59f017c 	ldr	r0, [pc, #380]	; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
   20564:	eb0083c3 	bl	41478 <printf>                                 <== NOT EXECUTED
   20568:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
   2056c:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
   20570:	e59f016c 	ldr	r0, [pc, #364]	; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
   20574:	eb0083bf 	bl	41478 <printf>                                 <== NOT EXECUTED
   20578:	e59d1028 	ldr	r1, [sp, #40]	; 0x28                          <== NOT EXECUTED
   2057c:	e59d2030 	ldr	r2, [sp, #48]	; 0x30                          <== NOT EXECUTED
   20580:	e59f015c 	ldr	r0, [pc, #348]	; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
   20584:	eb0083bb 	bl	41478 <printf>                                 <== NOT EXECUTED
   20588:	e59f0154 	ldr	r0, [pc, #340]	; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
   2058c:	e59d1034 	ldr	r1, [sp, #52]	; 0x34                          <== NOT EXECUTED
   20590:	e59d203c 	ldr	r2, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   20594:	eb0083b7 	bl	41478 <printf>                                 <== NOT EXECUTED
   20598:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   2059c:	ea00004b 	b	206d0 <rtems_shell_debugrfs+0x210>              <== NOT EXECUTED
        printf ("error: unknown option: %s\n", argv[arg]);            
        return 1;                                                     
    }                                                                 
  }                                                                   
                                                                      
  if ((argc - arg) < 2)                                               
   205a0:	e3550002 	cmp	r5, #2                                        <== NOT EXECUTED
   205a4:	1a000002 	bne	205b4 <rtems_shell_debugrfs+0xf4>             <== NOT EXECUTED
    printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
   205a8:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
   205ac:	e59f0134 	ldr	r0, [pc, #308]	; 206e8 <rtems_shell_debugrfs+0x228><== NOT EXECUTED
   205b0:	ea000044 	b	206c8 <rtems_shell_debugrfs+0x208>              <== NOT EXECUTED
rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)       
{                                                                     
  struct statvfs sb;                                                  
  int            rc;                                                  
                                                                      
  rc = statvfs (path, &sb);                                           
   205b4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   205b8:	e28d1040 	add	r1, sp, #64	; 0x40                            <== NOT EXECUTED
   205bc:	eb001929 	bl	26a68 <statvfs>                                <== NOT EXECUTED
  if (rc < 0)                                                         
   205c0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   205c4:	aa00000a 	bge	205f4 <rtems_shell_debugrfs+0x134>            <== NOT EXECUTED
  {                                                                   
    printf ("error: cannot statvfs path: %s: (%d) %s\n",              
   205c8:	eb00724c 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   205cc:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
   205d0:	eb00724a 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   205d4:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   205d8:	eb008bb9 	bl	434c4 <strerror>                               <== NOT EXECUTED
   205dc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   205e0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
   205e4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   205e8:	e59f00fc 	ldr	r0, [pc, #252]	; 206ec <rtems_shell_debugrfs+0x22c><== NOT EXECUTED
   205ec:	eb0083a1 	bl	41478 <printf>                                 <== NOT EXECUTED
   205f0:	ea000035 	b	206cc <rtems_shell_debugrfs+0x20c>              <== NOT EXECUTED
            path, errno, strerror (errno));                           
    return -1;                                                        
  }                                                                   
                                                                      
  if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)                                
   205f4:	e59d206c 	ldr	r2, [sp, #108]	; 0x6c                         <== NOT EXECUTED
   205f8:	e59f30f0 	ldr	r3, [pc, #240]	; 206f0 <rtems_shell_debugrfs+0x230><== NOT EXECUTED
   205fc:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
  {                                                                   
    printf ("error: path '%s' is not on an RFS file system\n", path); 
   20600:	11a01007 	movne	r1, r7                                      <== NOT EXECUTED
   20604:	159f00e8 	ldrne	r0, [pc, #232]	; 206f4 <rtems_shell_debugrfs+0x234><== NOT EXECUTED
    printf ("error: cannot statvfs path: %s: (%d) %s\n",              
            path, errno, strerror (errno));                           
    return -1;                                                        
  }                                                                   
                                                                      
  if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)                                
   20608:	1a00002e 	bne	206c8 <rtems_shell_debugrfs+0x208>            <== NOT EXECUTED
   * Now find the path location on the file system. This will give the file
   * system data.                                                     
   */                                                                 
  {                                                                   
    rtems_filesystem_location_info_t pathloc;                         
    rc = rtems_filesystem_evaluate_path (path, strlen (path), 0, &pathloc, true);
   2060c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   20610:	eb008d37 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   20614:	e28d6078 	add	r6, sp, #120	; 0x78                           <== NOT EXECUTED
   20618:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   2061c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   20620:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
   20624:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
   20628:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
   2062c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   20630:	ebff9c01 	bl	763c <rtems_filesystem_evaluate_path>          <== NOT EXECUTED
    *fs = rtems_rfs_rtems_pathloc_dev (&pathloc);                     
    rtems_filesystem_freenode (&pathloc);                             
   20634:	e59d3084 	ldr	r3, [sp, #132]	; 0x84                         <== NOT EXECUTED
   * system data.                                                     
   */                                                                 
  {                                                                   
    rtems_filesystem_location_info_t pathloc;                         
    rc = rtems_filesystem_evaluate_path (path, strlen (path), 0, &pathloc, true);
    *fs = rtems_rfs_rtems_pathloc_dev (&pathloc);                     
   20638:	e59d2088 	ldr	r2, [sp, #136]	; 0x88                         <== NOT EXECUTED
    rtems_filesystem_freenode (&pathloc);                             
   2063c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   * Now find the path location on the file system. This will give the file
   * system data.                                                     
   */                                                                 
  {                                                                   
    rtems_filesystem_location_info_t pathloc;                         
    rc = rtems_filesystem_evaluate_path (path, strlen (path), 0, &pathloc, true);
   20640:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    *fs = rtems_rfs_rtems_pathloc_dev (&pathloc);                     
   20644:	e5928034 	ldr	r8, [r2, #52]	; 0x34                          <== NOT EXECUTED
    rtems_filesystem_freenode (&pathloc);                             
   20648:	0a000004 	beq	20660 <rtems_shell_debugrfs+0x1a0>            <== NOT EXECUTED
   2064c:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   20650:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   20654:	11a00006 	movne	r0, r6                                      <== NOT EXECUTED
   20658:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   2065c:	112fff13 	bxne	r3                                           <== NOT EXECUTED
  if ((argc - arg) < 2)                                               
    printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
  else                                                                
  {                                                                   
    rtems_rfs_file_system* fs;                                        
    if (rtems_rfs_get_fs (argv[arg], &fs) == 0)                       
   20660:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    {                                                                 
      for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
        if (strcmp (argv[arg + 1], table[t].name) == 0)               
   20664:	02844008 	addeq	r4, r4, #8                                  <== NOT EXECUTED
  if ((argc - arg) < 2)                                               
    printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
  else                                                                
  {                                                                   
    rtems_rfs_file_system* fs;                                        
    if (rtems_rfs_get_fs (argv[arg], &fs) == 0)                       
   20668:	01a06007 	moveq	r6, r7                                      <== NOT EXECUTED
    {                                                                 
      for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
        if (strcmp (argv[arg + 1], table[t].name) == 0)               
   2066c:	028da004 	addeq	sl, sp, #4                                  <== NOT EXECUTED
  if ((argc - arg) < 2)                                               
    printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
  else                                                                
  {                                                                   
    rtems_rfs_file_system* fs;                                        
    if (rtems_rfs_get_fs (argv[arg], &fs) == 0)                       
   20670:	1a000015 	bne	206cc <rtems_shell_debugrfs+0x20c>            <== NOT EXECUTED
    {                                                                 
      for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
        if (strcmp (argv[arg + 1], table[t].name) == 0)               
   20674:	e79a1007 	ldr	r1, [sl, r7]                                  <== NOT EXECUTED
   20678:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
   2067c:	eb008ab4 	bl	43154 <strcmp>                                 <== NOT EXECUTED
   20680:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   20684:	e287700c 	add	r7, r7, #12                                   <== NOT EXECUTED
   20688:	1a000009 	bne	206b4 <rtems_shell_debugrfs+0x1f4>            <== NOT EXECUTED
          return table[t].handler (fs, argc - 2, argv + 2);           
   2068c:	e3a02003 	mov	r2, #3                                        <== NOT EXECUTED
   20690:	e0030692 	mul	r3, r2, r6                                    <== NOT EXECUTED
   20694:	e28d208c 	add	r2, sp, #140	; 0x8c                           <== NOT EXECUTED
   20698:	e0823103 	add	r3, r2, r3, lsl #2                            <== NOT EXECUTED
   2069c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   206a0:	e2451002 	sub	r1, r5, #2                                    <== NOT EXECUTED
   206a4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
   206a8:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   206ac:	e513f084 	ldr	pc, [r3, #-132]	; 0x84                        <== NOT EXECUTED
   206b0:	ea000006 	b	206d0 <rtems_shell_debugrfs+0x210>              <== NOT EXECUTED
  else                                                                
  {                                                                   
    rtems_rfs_file_system* fs;                                        
    if (rtems_rfs_get_fs (argv[arg], &fs) == 0)                       
    {                                                                 
      for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
   206b4:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
   206b8:	e3560005 	cmp	r6, #5                                        <== NOT EXECUTED
   206bc:	1affffec 	bne	20674 <rtems_shell_debugrfs+0x1b4>            <== NOT EXECUTED
        if (strcmp (argv[arg + 1], table[t].name) == 0)               
          return table[t].handler (fs, argc - 2, argv + 2);           
      printf ("error: command not found: %s\n", argv[arg + 1]);       
   206c0:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
   206c4:	e59f002c 	ldr	r0, [pc, #44]	; 206f8 <rtems_shell_debugrfs+0x238><== NOT EXECUTED
   206c8:	eb00836a 	bl	41478 <printf>                                 <== NOT EXECUTED
   206cc:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return 1;                                                           
}                                                                     
   206d0:	e28dd08c 	add	sp, sp, #140	; 0x8c                           <== NOT EXECUTED
   206d4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

0001f6b8 <rtems_shell_rfs_format>: return 1; } int rtems_shell_rfs_format (int argc, char* argv[]) {
   1f6b8:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
   1f6bc:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
   1f6c0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
   1f6c4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  rtems_rfs_format_config config;                                     
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
   1f6c8:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
   1f6cc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1f6d0:	e3a02018 	mov	r2, #24                                       <== NOT EXECUTED
   1f6d4:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
   1f6d8:	eb00833f 	bl	403dc <memset>                                 <== NOT EXECUTED
   1f6dc:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'v':                                                     
          config.verbose = true;                                      
   1f6e0:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
   1f6e4:	ea000049 	b	1f810 <rtems_shell_rfs_format+0x158>            <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
   1f6e8:	e7961104 	ldr	r1, [r6, r4, lsl #2]                          <== NOT EXECUTED
   1f6ec:	e5d13000 	ldrb	r3, [r1]                                     <== NOT EXECUTED
   1f6f0:	e353002d 	cmp	r3, #45	; 0x2d                                <== NOT EXECUTED
   1f6f4:	1a00003e 	bne	1f7f4 <rtems_shell_rfs_format+0x13c>          <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
   1f6f8:	e5d13001 	ldrb	r3, [r1, #1]                                 <== NOT EXECUTED
   1f6fc:	e3530069 	cmp	r3, #105	; 0x69                               <== NOT EXECUTED
   1f700:	0a000023 	beq	1f794 <rtems_shell_rfs_format+0xdc>           <== NOT EXECUTED
   1f704:	8a000004 	bhi	1f71c <rtems_shell_rfs_format+0x64>           <== NOT EXECUTED
   1f708:	e3530049 	cmp	r3, #73	; 0x49                                <== NOT EXECUTED
   1f70c:	0a00002a 	beq	1f7bc <rtems_shell_rfs_format+0x104>          <== NOT EXECUTED
   1f710:	e3530062 	cmp	r3, #98	; 0x62                                <== NOT EXECUTED
   1f714:	1a000034 	bne	1f7ec <rtems_shell_rfs_format+0x134>          <== NOT EXECUTED
   1f718:	ea000013 	b	1f76c <rtems_shell_rfs_format+0xb4>             <== NOT EXECUTED
   1f71c:	e3530073 	cmp	r3, #115	; 0x73                               <== NOT EXECUTED
   1f720:	0a000006 	beq	1f740 <rtems_shell_rfs_format+0x88>           <== NOT EXECUTED
   1f724:	e3530076 	cmp	r3, #118	; 0x76                               <== NOT EXECUTED
   1f728:	0a000002 	beq	1f738 <rtems_shell_rfs_format+0x80>           <== NOT EXECUTED
   1f72c:	e353006f 	cmp	r3, #111	; 0x6f                               <== NOT EXECUTED
   1f730:	1a00002d 	bne	1f7ec <rtems_shell_rfs_format+0x134>          <== NOT EXECUTED
   1f734:	ea000022 	b	1f7c4 <rtems_shell_rfs_format+0x10c>            <== NOT EXECUTED
      {                                                               
        case 'v':                                                     
          config.verbose = true;                                      
   1f738:	e5cd8015 	strb	r8, [sp, #21]                                <== NOT EXECUTED
   1f73c:	ea000008 	b	1f764 <rtems_shell_rfs_format+0xac>             <== NOT EXECUTED
          break;                                                      
                                                                      
        case 's':                                                     
          arg++;                                                      
   1f740:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
          if (arg >= argc)                                            
   1f744:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
          {                                                           
            printf ("error: block size needs an argument\n");         
   1f748:	a59f011c 	ldrge	r0, [pc, #284]	; 1f86c <rtems_shell_rfs_format+0x1b4><== NOT EXECUTED
   1f74c:	aa000034 	bge	1f824 <rtems_shell_rfs_format+0x16c>          <== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.block_size = strtoul (argv[arg], 0, 0);              
   1f750:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1f754:	e7960104 	ldr	r0, [r6, r4, lsl #2]                          <== NOT EXECUTED
   1f758:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1f75c:	eb009600 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1f760:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
   1f764:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
          break;                                                      
   1f768:	ea000026 	b	1f808 <rtems_shell_rfs_format+0x150>            <== NOT EXECUTED
                                                                      
        case 'b':                                                     
          arg++;                                                      
   1f76c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
          if (arg >= argc)                                            
   1f770:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
          {                                                           
            printf ("error: group block count needs an argument\n");  
   1f774:	a59f00f4 	ldrge	r0, [pc, #244]	; 1f870 <rtems_shell_rfs_format+0x1b8><== NOT EXECUTED
   1f778:	aa000029 	bge	1f824 <rtems_shell_rfs_format+0x16c>          <== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.group_blocks = strtoul (argv[arg], 0, 0);            
   1f77c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1f780:	e7960104 	ldr	r0, [r6, r4, lsl #2]                          <== NOT EXECUTED
   1f784:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1f788:	eb0095f5 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1f78c:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
   1f790:	eafffff3 	b	1f764 <rtems_shell_rfs_format+0xac>             <== NOT EXECUTED
          break;                                                      
                                                                      
        case 'i':                                                     
          arg++;                                                      
   1f794:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
          if (arg >= argc)                                            
   1f798:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
          {                                                           
            printf ("error: group inode count needs an argument\n");  
   1f79c:	a59f00d0 	ldrge	r0, [pc, #208]	; 1f874 <rtems_shell_rfs_format+0x1bc><== NOT EXECUTED
   1f7a0:	aa00001f 	bge	1f824 <rtems_shell_rfs_format+0x16c>          <== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.group_inodes = strtoul (argv[arg], 0, 0);            
   1f7a4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1f7a8:	e7960104 	ldr	r0, [r6, r4, lsl #2]                          <== NOT EXECUTED
   1f7ac:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1f7b0:	eb0095eb 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1f7b4:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
   1f7b8:	eaffffe9 	b	1f764 <rtems_shell_rfs_format+0xac>             <== NOT EXECUTED
          break;                                                      
                                                                      
        case 'I':                                                     
          config.initialise_inodes = true;                            
   1f7bc:	e5cd8014 	strb	r8, [sp, #20]                                <== NOT EXECUTED
   1f7c0:	eaffffe7 	b	1f764 <rtems_shell_rfs_format+0xac>             <== NOT EXECUTED
          break;                                                      
                                                                      
        case 'o':                                                     
          arg++;                                                      
   1f7c4:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
          if (arg >= argc)                                            
   1f7c8:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
   1f7cc:	a59f00a4 	ldrge	r0, [pc, #164]	; 1f878 <rtems_shell_rfs_format+0x1c0><== NOT EXECUTED
   1f7d0:	aa000013 	bge	1f824 <rtems_shell_rfs_format+0x16c>          <== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.inode_overhead = strtoul (argv[arg], 0, 0);          
   1f7d4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
   1f7d8:	e7960104 	ldr	r0, [r6, r4, lsl #2]                          <== NOT EXECUTED
   1f7dc:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
   1f7e0:	eb0095df 	bl	44f64 <strtoul>                                <== NOT EXECUTED
   1f7e4:	e58d000c 	str	r0, [sp, #12]                                 <== NOT EXECUTED
   1f7e8:	eaffffdd 	b	1f764 <rtems_shell_rfs_format+0xac>             <== NOT EXECUTED
          break;                                                      
                                                                      
        default:                                                      
          printf ("error: invalid option: %s\n", argv[arg]);          
   1f7ec:	e59f0088 	ldr	r0, [pc, #136]	; 1f87c <rtems_shell_rfs_format+0x1c4><== NOT EXECUTED
   1f7f0:	ea000002 	b	1f800 <rtems_shell_rfs_format+0x148>            <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (!driver)                                                    
   1f7f4:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   1f7f8:	0a000002 	beq	1f808 <rtems_shell_rfs_format+0x150>          <== NOT EXECUTED
        driver = argv[arg];                                           
      else                                                            
      {                                                               
        printf ("error: only one driver name allowed: %s\n", argv[arg]);
   1f7fc:	e59f007c 	ldr	r0, [pc, #124]	; 1f880 <rtems_shell_rfs_format+0x1c8><== NOT EXECUTED
   1f800:	eb00871c 	bl	41478 <printf>                                 <== NOT EXECUTED
   1f804:	ea000015 	b	1f860 <rtems_shell_rfs_format+0x1a8>            <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
   1f808:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
   1f80c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   1f810:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
   1f814:	baffffb3 	blt	1f6e8 <rtems_shell_rfs_format+0x30>           <== NOT EXECUTED
        return 1;                                                     
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
   1f818:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
   1f81c:	1a000002 	bne	1f82c <rtems_shell_rfs_format+0x174>          <== NOT EXECUTED
    printf ("error: no driver name provided\n");                      
   1f820:	e59f005c 	ldr	r0, [pc, #92]	; 1f884 <rtems_shell_rfs_format+0x1cc><== NOT EXECUTED
   1f824:	eb0087b8 	bl	4170c <puts>                                   <== NOT EXECUTED
   1f828:	ea00000c 	b	1f860 <rtems_shell_rfs_format+0x1a8>            <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_format (driver, &config) < 0)                         
   1f82c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   1f830:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
   1f834:	eb005b2f 	bl	364f8 <rtems_rfs_format>                       <== NOT EXECUTED
   1f838:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   1f83c:	a3a00000 	movge	r0, #0                                      <== NOT EXECUTED
   1f840:	aa000007 	bge	1f864 <rtems_shell_rfs_format+0x1ac>          <== NOT EXECUTED
  {                                                                   
    printf ("error: format of %s failed: %s\n",                       
   1f844:	eb0075ad 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1f848:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   1f84c:	eb008f1c 	bl	434c4 <strerror>                               <== NOT EXECUTED
   1f850:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   1f854:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
   1f858:	e59f0028 	ldr	r0, [pc, #40]	; 1f888 <rtems_shell_rfs_format+0x1d0><== NOT EXECUTED
   1f85c:	eb008705 	bl	41478 <printf>                                 <== NOT EXECUTED
   1f860:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
            driver, strerror (errno));                                
    return 1;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
   1f864:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
   1f868:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00005e58 <rtems_stack_checker_is_blown>: /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) {
    5e58:	e92d4810 	push	{r4, fp, lr}                                 
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
    5e5c:	e59f307c 	ldr	r3, [pc, #124]	; 5ee0 <rtems_stack_checker_is_blown+0x88>
    5e60:	e5933000 	ldr	r3, [r3]                                      
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
    5e64:	e59300c4 	ldr	r0, [r3, #196]	; 0xc4                         
                                                                      
/*                                                                    
 *  Check if blown                                                    
 */                                                                   
bool rtems_stack_checker_is_blown( void )                             
{                                                                     
    5e68:	e28db008 	add	fp, sp, #8                                    
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
    5e6c:	e15b0000 	cmp	fp, r0                                        
    5e70:	33a04000 	movcc	r4, #0                                      
    5e74:	3a000004 	bcc	5e8c <rtems_stack_checker_is_blown+0x34>      
}                                                                     
                                                                      
/*                                                                    
 *  Check if blown                                                    
 */                                                                   
bool rtems_stack_checker_is_blown( void )                             
    5e78:	e59340c0 	ldr	r4, [r3, #192]	; 0xc0                         
    5e7c:	e0804004 	add	r4, r0, r4                                    
    5e80:	e15b0004 	cmp	fp, r4                                        
    5e84:	83a04000 	movhi	r4, #0                                      
    5e88:	93a04001 	movls	r4, #1                                      
                                                                      
  /*                                                                  
   * The stack checker must be initialized before the pattern is there
   * to check.                                                        
   */                                                                 
  if ( Stack_check_Initialized ) {                                    
    5e8c:	e59f3050 	ldr	r3, [pc, #80]	; 5ee4 <rtems_stack_checker_is_blown+0x8c>
    5e90:	e5933000 	ldr	r3, [r3]                                      
    5e94:	e3530000 	cmp	r3, #0                                        
    5e98:	03a01001 	moveq	r1, #1                                      
    5e9c:	0a000005 	beq	5eb8 <rtems_stack_checker_is_blown+0x60>      
    pattern_ok = (!memcmp(                                            
    5ea0:	e59f1040 	ldr	r1, [pc, #64]	; 5ee8 <rtems_stack_checker_is_blown+0x90>
    5ea4:	e2800008 	add	r0, r0, #8                                    
    5ea8:	e3a02010 	mov	r2, #16                                       
    5eac:	eb00e899 	bl	40118 <memcmp>                                 
    5eb0:	e2701001 	rsbs	r1, r0, #1                                   
    5eb4:	33a01000 	movcc	r1, #0                                      
  }                                                                   
                                                                      
  /*                                                                  
   * The Stack Pointer and the Pattern Area are OK so return false.   
   */                                                                 
  if ( sp_ok && pattern_ok )                                          
    5eb8:	e3540000 	cmp	r4, #0                                        
    5ebc:	0a000002 	beq	5ecc <rtems_stack_checker_is_blown+0x74>      
    5ec0:	e3510000 	cmp	r1, #0                                        
    5ec4:	13a00000 	movne	r0, #0                                      
    5ec8:	18bd8810 	popne	{r4, fp, pc}                                
    return false;                                                     
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  Stack_check_report_blown_task( _Thread_Executing, pattern_ok );     
    5ecc:	e59f300c 	ldr	r3, [pc, #12]	; 5ee0 <rtems_stack_checker_is_blown+0x88><== NOT EXECUTED
    5ed0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    5ed4:	ebffffb4 	bl	5dac <Stack_check_report_blown_task>           <== NOT EXECUTED
    5ed8:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
  return true;                                                        
}                                                                     
    5edc:	e8bd8810 	pop	{r4, fp, pc}                                  <== NOT EXECUTED
                                                                      

00005d9c <rtems_stack_checker_report_usage>: void rtems_stack_checker_report_usage( void ) { rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
    5d9c:	e59f1004 	ldr	r1, [pc, #4]	; 5da8 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED
    5da0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    5da4:	eaffffe3 	b	5d38 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
                                                                      

00005d38 <rtems_stack_checker_report_usage_with_plugin>: void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) {
    5d38:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  print_context = context;                                            
    5d3c:	e59f4048 	ldr	r4, [pc, #72]	; 5d8c <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
                                                                      
void rtems_stack_checker_report_usage_with_plugin(                    
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
    5d40:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    5d44:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  print_context = context;                                            
  print_handler = print;                                              
    5d48:	e5841004 	str	r1, [r4, #4]                                  <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(                    
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
  print_context = context;                                            
    5d4c:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
  print_handler = print;                                              
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
    5d50:	e59f1038 	ldr	r1, [pc, #56]	; 5d90 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
    5d54:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5d58:	e12fff15 	bx	r5                                             <== NOT EXECUTED
  (*print)( context,                                                  
    5d5c:	e59f1030 	ldr	r1, [pc, #48]	; 5d94 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED
    5d60:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    5d64:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    5d68:	e12fff15 	bx	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 );   
    5d6c:	e59f0024 	ldr	r0, [pc, #36]	; 5d98 <rtems_stack_checker_report_usage_with_plugin+0x60><== NOT EXECUTED
    5d70:	eb001c02 	bl	cd80 <rtems_iterate_over_all_threads>          <== NOT EXECUTED
                                                                      
  /* dump interrupt stack info if any */                              
  Stack_check_Dump_threads_usage((Thread_Control *) -1);              
    5d74:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
    5d78:	ebffff9f 	bl	5bfc <Stack_check_Dump_threads_usage>          <== NOT EXECUTED
                                                                      
  print_context = NULL;                                               
    5d7c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  print_handler = NULL;                                               
    5d80:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
  rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );   
                                                                      
  /* dump interrupt stack info if any */                              
  Stack_check_Dump_threads_usage((Thread_Control *) -1);              
                                                                      
  print_context = NULL;                                               
    5d84:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
  print_handler = NULL;                                               
                                                                      
}                                                                     
    5d88:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

0000ad80 <rtems_string_to_double>: rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) {
    ad80:	e92d41f1 	push	{r0, r4, r5, r6, r7, r8, lr}                 
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    ad84:	e2516000 	subs	r6, r1, #0                                   
rtems_status_code rtems_string_to_double (                            
  const char *s,                                                      
  double *n,                                                          
  char **endptr                                                       
)                                                                     
{                                                                     
    ad88:	e1a07000 	mov	r7, r0                                        
    ad8c:	e1a08002 	mov	r8, r2                                        
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    ad90:	03a00009 	moveq	r0, #9                                      
    ad94:	0a00002e 	beq	ae54 <rtems_string_to_double+0xd4>            
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
    ad98:	eb00084f 	bl	cedc <__errno>                                 
    ad9c:	e3a03000 	mov	r3, #0                                        
    ada0:	e5803000 	str	r3, [r0]                                      
  *n = 0;                                                             
    ada4:	e3a04000 	mov	r4, #0                                        
    ada8:	e3a03000 	mov	r3, #0                                        
    adac:	e8860018 	stm	r6, {r3, r4}                                  
                                                                      
  result = strtod( s, &end );                                         
    adb0:	e1a00007 	mov	r0, r7                                        
    adb4:	e1a0100d 	mov	r1, sp                                        
    adb8:	eb0013c5 	bl	fcd4 <strtod>                                  
                                                                      
  if ( endptr )                                                       
    adbc:	e3580000 	cmp	r8, #0                                        
    *endptr = end;                                                    
    adc0:	159d3000 	ldrne	r3, [sp]                                    
    adc4:	15883000 	strne	r3, [r8]                                    
                                                                      
  if ( end == s )                                                     
    adc8:	e59d3000 	ldr	r3, [sp]                                      
    adcc:	e1530007 	cmp	r3, r7                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtod( s, &end );                                         
    add0:	e1a04000 	mov	r4, r0                                        
    add4:	e1a05001 	mov	r5, r1                                        
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    add8:	03a0000b 	moveq	r0, #11                                     
    addc:	0a00001c 	beq	ae54 <rtems_string_to_double+0xd4>            
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    ade0:	eb00083d 	bl	cedc <__errno>                                 
    ade4:	e5903000 	ldr	r3, [r0]                                      
    ade8:	e3530022 	cmp	r3, #34	; 0x22                                
    adec:	1a000014 	bne	ae44 <rtems_string_to_double+0xc4>            
    adf0:	e1a00004 	mov	r0, r4                                        
    adf4:	e1a01005 	mov	r1, r5                                        
    adf8:	e3a02000 	mov	r2, #0                                        
    adfc:	e3a03000 	mov	r3, #0                                        
    ae00:	ebffdf79 	bl	2bec <__cmpdf2>                                
    ae04:	e3500000 	cmp	r0, #0                                        
    ae08:	0a000010 	beq	ae50 <rtems_string_to_double+0xd0>            
    ae0c:	e1a00004 	mov	r0, r4                                        
    ae10:	e1a01005 	mov	r1, r5                                        
    ae14:	e3e02000 	mvn	r2, #0                                        
    ae18:	e59f3038 	ldr	r3, [pc, #56]	; ae58 <rtems_string_to_double+0xd8>
    ae1c:	ebffdf6e 	bl	2bdc <__gedf2>                                 
    ae20:	e3500000 	cmp	r0, #0                                        
    ae24:	ca000009 	bgt	ae50 <rtems_string_to_double+0xd0>            
    ae28:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    ae2c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    ae30:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
    ae34:	e3e03601 	mvn	r3, #1048576	; 0x100000                       <== NOT EXECUTED
    ae38:	ebffdf69 	bl	2be4 <__ledf2>                                 <== NOT EXECUTED
    ae3c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    ae40:	ba000002 	blt	ae50 <rtems_string_to_double+0xd0>            <== NOT EXECUTED
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
    ae44:	e8860030 	stm	r6, {r4, r5}                                  
    ae48:	e3a00000 	mov	r0, #0                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
    ae4c:	ea000000 	b	ae54 <rtems_string_to_double+0xd4>              
    ae50:	e3a0000a 	mov	r0, #10                                       
}                                                                     
    ae54:	e8bd81f8 	pop	{r3, r4, r5, r6, r7, r8, pc}                  
                                                                      

0000ae5c <rtems_string_to_float>: rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) {
    ae5c:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    ae60:	e2514000 	subs	r4, r1, #0                                   
rtems_status_code rtems_string_to_float (                             
  const char *s,                                                      
  float *n,                                                           
  char **endptr                                                       
)                                                                     
{                                                                     
    ae64:	e1a05000 	mov	r5, r0                                        
    ae68:	e1a07002 	mov	r7, r2                                        
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    ae6c:	03a00009 	moveq	r0, #9                                      
    ae70:	0a000026 	beq	af10 <rtems_string_to_float+0xb4>             
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
    ae74:	eb000818 	bl	cedc <__errno>                                 
    ae78:	e3a03000 	mov	r3, #0                                        
    ae7c:	e5803000 	str	r3, [r0]                                      
  *n = 0;                                                             
    ae80:	e3a03000 	mov	r3, #0                                        
    ae84:	e5843000 	str	r3, [r4]                                      
                                                                      
  result = strtof( s, &end );                                         
    ae88:	e1a00005 	mov	r0, r5                                        
    ae8c:	e1a0100d 	mov	r1, sp                                        
    ae90:	eb00137c 	bl	fc88 <strtof>                                  
                                                                      
  if ( endptr )                                                       
    ae94:	e3570000 	cmp	r7, #0                                        
    *endptr = end;                                                    
    ae98:	159d3000 	ldrne	r3, [sp]                                    
    ae9c:	15873000 	strne	r3, [r7]                                    
                                                                      
  if ( end == s )                                                     
    aea0:	e59d3000 	ldr	r3, [sp]                                      
    aea4:	e1530005 	cmp	r3, r5                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtof( s, &end );                                         
    aea8:	e1a06000 	mov	r6, r0                                        
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    aeac:	03a0000b 	moveq	r0, #11                                     
    aeb0:	0a000016 	beq	af10 <rtems_string_to_float+0xb4>             
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    aeb4:	eb000808 	bl	cedc <__errno>                                 
    aeb8:	e5903000 	ldr	r3, [r0]                                      
    aebc:	e3530022 	cmp	r3, #34	; 0x22                                
    aec0:	1a00000e 	bne	af00 <rtems_string_to_float+0xa4>             
    aec4:	e1a00006 	mov	r0, r6                                        
    aec8:	e3a01000 	mov	r1, #0                                        
    aecc:	ebffdf91 	bl	2d18 <__cmpsf2>                                
    aed0:	e3500000 	cmp	r0, #0                                        
    aed4:	0a00000c 	beq	af0c <rtems_string_to_float+0xb0>             
    aed8:	e1a00006 	mov	r0, r6                                        
    aedc:	e59f1030 	ldr	r1, [pc, #48]	; af14 <rtems_string_to_float+0xb8>
    aee0:	ebffdf88 	bl	2d08 <__gesf2>                                 
    aee4:	e3500000 	cmp	r0, #0                                        
    aee8:	ca000007 	bgt	af0c <rtems_string_to_float+0xb0>             
    aeec:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    aef0:	e3e01502 	mvn	r1, #8388608	; 0x800000                       <== NOT EXECUTED
    aef4:	ebffdf85 	bl	2d10 <__lesf2>                                 <== NOT EXECUTED
    aef8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    aefc:	ba000002 	blt	af0c <rtems_string_to_float+0xb0>             <== NOT EXECUTED
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
    af00:	e5846000 	str	r6, [r4]                                      
    af04:	e3a00000 	mov	r0, #0                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
    af08:	ea000000 	b	af10 <rtems_string_to_float+0xb4>               
    af0c:	e3a0000a 	mov	r0, #10                                       
}                                                                     
    af10:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      
                                                                      

0001c1c4 <rtems_string_to_int>: const char *s, int *n, char **endptr, int base ) {
   1c1c4:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
   1c1c8:	e2514000 	subs	r4, r1, #0                                   
  const char *s,                                                      
  int *n,                                                             
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
   1c1cc:	e1a05000 	mov	r5, r0                                        
   1c1d0:	e1a06002 	mov	r6, r2                                        
   1c1d4:	e1a07003 	mov	r7, r3                                        
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
   1c1d8:	03a00009 	moveq	r0, #9                                      
   1c1dc:	0a00001c 	beq	1c254 <rtems_string_to_int+0x90>              
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
   1c1e0:	eb008346 	bl	3cf00 <__errno>                                
   1c1e4:	e3a03000 	mov	r3, #0                                        
   1c1e8:	e5803000 	str	r3, [r0]                                      
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
   1c1ec:	e1a02007 	mov	r2, r7                                        
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
   1c1f0:	e5843000 	str	r3, [r4]                                      
                                                                      
  result = strtol( s, &end, base );                                   
   1c1f4:	e1a00005 	mov	r0, r5                                        
   1c1f8:	e1a0100d 	mov	r1, sp                                        
   1c1fc:	eb00a23b 	bl	44af0 <strtol>                                 
                                                                      
  if ( endptr )                                                       
   1c200:	e3560000 	cmp	r6, #0                                        
    *endptr = end;                                                    
   1c204:	159d3000 	ldrne	r3, [sp]                                    
   1c208:	15863000 	strne	r3, [r6]                                    
                                                                      
  if ( end == s )                                                     
   1c20c:	e59d3000 	ldr	r3, [sp]                                      
   1c210:	e1530005 	cmp	r3, r5                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
   1c214:	e1a07000 	mov	r7, r0                                        
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
   1c218:	03a0000b 	moveq	r0, #11                                     
   1c21c:	0a00000c 	beq	1c254 <rtems_string_to_int+0x90>              
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
   1c220:	eb008336 	bl	3cf00 <__errno>                                
   1c224:	e5903000 	ldr	r3, [r0]                                      
   1c228:	e3530022 	cmp	r3, #34	; 0x22                                
   1c22c:	1a000004 	bne	1c244 <rtems_string_to_int+0x80>              
   1c230:	e3770106 	cmn	r7, #-2147483647	; 0x80000001                 
   1c234:	13570000 	cmpne	r7, #0                                      
   1c238:	0a000004 	beq	1c250 <rtems_string_to_int+0x8c>              
   1c23c:	e3570102 	cmp	r7, #-2147483648	; 0x80000000                 <== NOT EXECUTED
   1c240:	0a000002 	beq	1c250 <rtems_string_to_int+0x8c>              <== NOT EXECUTED
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
   1c244:	e5847000 	str	r7, [r4]                                      
   1c248:	e3a00000 	mov	r0, #0                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
   1c24c:	ea000000 	b	1c254 <rtems_string_to_int+0x90>                
   1c250:	e3a0000a 	mov	r0, #10                                       
}                                                                     
   1c254:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      
                                                                      

0001c260 <rtems_string_to_unsigned_char>: const char *s, unsigned char *n, char **endptr, int base ) {
   1c260:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
   1c264:	e2514000 	subs	r4, r1, #0                                   
  const char *s,                                                      
  unsigned char *n,                                                   
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
   1c268:	e1a05000 	mov	r5, r0                                        
   1c26c:	e1a06002 	mov	r6, r2                                        
   1c270:	e1a07003 	mov	r7, r3                                        
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
   1c274:	03a00009 	moveq	r0, #9                                      
   1c278:	0a00001e 	beq	1c2f8 <rtems_string_to_unsigned_char+0x98>    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
   1c27c:	eb00831f 	bl	3cf00 <__errno>                                
   1c280:	e3a03000 	mov	r3, #0                                        
   1c284:	e5803000 	str	r3, [r0]                                      
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
   1c288:	e1a02007 	mov	r2, r7                                        
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
   1c28c:	e5c43000 	strb	r3, [r4]                                     
                                                                      
  result = strtoul( s, &end, base );                                  
   1c290:	e1a00005 	mov	r0, r5                                        
   1c294:	e1a0100d 	mov	r1, sp                                        
   1c298:	eb00a331 	bl	44f64 <strtoul>                                
                                                                      
  if ( endptr )                                                       
   1c29c:	e3560000 	cmp	r6, #0                                        
    *endptr = end;                                                    
   1c2a0:	159d3000 	ldrne	r3, [sp]                                    
   1c2a4:	15863000 	strne	r3, [r6]                                    
                                                                      
  if ( end == s )                                                     
   1c2a8:	e59d3000 	ldr	r3, [sp]                                      
   1c2ac:	e1530005 	cmp	r3, r5                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
   1c2b0:	e1a07000 	mov	r7, r0                                        
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
   1c2b4:	03a0000b 	moveq	r0, #11                                     
   1c2b8:	0a00000e 	beq	1c2f8 <rtems_string_to_unsigned_char+0x98>    
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
   1c2bc:	eb00830f 	bl	3cf00 <__errno>                                
   1c2c0:	e5903000 	ldr	r3, [r0]                                      
   1c2c4:	e3530022 	cmp	r3, #34	; 0x22                                
   1c2c8:	1a000002 	bne	1c2d8 <rtems_string_to_unsigned_char+0x78>    
   1c2cc:	e2473001 	sub	r3, r7, #1                                    <== NOT EXECUTED
   1c2d0:	e3730003 	cmn	r3, #3                                        <== NOT EXECUTED
   1c2d4:	8a000006 	bhi	1c2f4 <rtems_string_to_unsigned_char+0x94>    <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
   1c2d8:	e35700ff 	cmp	r7, #255	; 0xff                               
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
   1c2dc:	95c47000 	strbls	r7, [r4]                                   
   1c2e0:	93a00000 	movls	r0, #0                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
   1c2e4:	9a000003 	bls	1c2f8 <rtems_string_to_unsigned_char+0x98>    
    errno = ERANGE;                                                   
   1c2e8:	eb008304 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   1c2ec:	e3a03022 	mov	r3, #34	; 0x22                                <== NOT EXECUTED
   1c2f0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   1c2f4:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
#endif                                                                
                                                                      
  *n = result;                                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
   1c2f8:	e8bd80f8 	pop	{r3, r4, r5, r6, r7, pc}                      
                                                                      

000042c4 <rtems_termios_baud_to_index>: rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) {
    42c4:	e3500009 	cmp	r0, #9                                        
    42c8:	012fff1e 	bxeq	lr                                           
    42cc:	ca000016 	bgt	432c <rtems_termios_baud_to_index+0x68>       
    42d0:	e3500004 	cmp	r0, #4                                        
    42d4:	012fff1e 	bxeq	lr                                           
    42d8:	ca00000a 	bgt	4308 <rtems_termios_baud_to_index+0x44>       
    42dc:	e3500001 	cmp	r0, #1                                        
    42e0:	012fff1e 	bxeq	lr                                           
    42e4:	ca000002 	bgt	42f4 <rtems_termios_baud_to_index+0x30>       
    42e8:	e3500000 	cmp	r0, #0                                        
    42ec:	012fff1e 	bxeq	lr                                           
    42f0:	ea000030 	b	43b8 <rtems_termios_baud_to_index+0xf4>         
    42f4:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
    42f8:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    42fc:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
    4300:	1a00002c 	bne	43b8 <rtems_termios_baud_to_index+0xf4>       <== NOT EXECUTED
    4304:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    4308:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
    430c:	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;                          
    4310:	b3a00005 	movlt	r0, #5                                      <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
    4314:	b12fff1e 	bxlt	lr                                           <== NOT EXECUTED
    4318:	e3500007 	cmp	r0, #7                                        <== NOT EXECUTED
    431c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    4320:	e3500008 	cmp	r0, #8                                        <== NOT EXECUTED
    4324:	1a000023 	bne	43b8 <rtems_termios_baud_to_index+0xf4>       <== NOT EXECUTED
    4328:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    432c:	e350000e 	cmp	r0, #14                                       <== NOT EXECUTED
    4330:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    4334:	ca000008 	bgt	435c <rtems_termios_baud_to_index+0x98>       <== NOT EXECUTED
    4338:	e350000b 	cmp	r0, #11                                       <== NOT EXECUTED
    433c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    case B134:      baud_index =  4;  break;                          
    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;                          
    4340:	b3a0000a 	movlt	r0, #10                                     <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
    4344:	b12fff1e 	bxlt	lr                                           <== NOT EXECUTED
    4348:	e350000c 	cmp	r0, #12                                       <== NOT EXECUTED
    434c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    4350:	e350000d 	cmp	r0, #13                                       <== NOT EXECUTED
    4354:	1a000017 	bne	43b8 <rtems_termios_baud_to_index+0xf4>       <== NOT EXECUTED
    4358:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    435c:	e59f305c 	ldr	r3, [pc, #92]	; 43c0 <rtems_termios_baud_to_index+0xfc><== NOT EXECUTED
    4360:	e1500003 	cmp	r0, r3                                        <== 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;                          
    4364:	03a00011 	moveq	r0, #17                                     <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
    4368:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    436c:	ca000005 	bgt	4388 <rtems_termios_baud_to_index+0xc4>       <== NOT EXECUTED
    4370:	e350000f 	cmp	r0, #15                                       <== NOT EXECUTED
    4374:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    4378:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    437c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    4380:	1a00000c 	bne	43b8 <rtems_termios_baud_to_index+0xf4>       <== NOT EXECUTED
    4384:	ea000007 	b	43a8 <rtems_termios_baud_to_index+0xe4>         <== NOT EXECUTED
    4388:	e59f3034 	ldr	r3, [pc, #52]	; 43c4 <rtems_termios_baud_to_index+0x100><== NOT EXECUTED
    438c:	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;                          
    4390:	03a00012 	moveq	r0, #18                                     <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
    4394:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    4398:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
    439c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    43a0:	1a000004 	bne	43b8 <rtems_termios_baud_to_index+0xf4>       <== NOT EXECUTED
    43a4:	ea000001 	b	43b0 <rtems_termios_baud_to_index+0xec>         <== NOT EXECUTED
    case B1800:     baud_index = 10;  break;                          
    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;                          
    43a8:	e3a00010 	mov	r0, #16                                       <== NOT EXECUTED
    case B57600:    baud_index = 16;  break;                          
    43ac:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    43b0:	e3a00013 	mov	r0, #19                                       <== NOT EXECUTED
    case B460800:   baud_index = 19;  break;                          
    43b4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    43b8:	e3e00000 	mvn	r0, #0                                        
    default:        baud_index = -1;  break;                          
  }                                                                   
                                                                      
  return baud_index;                                                  
}                                                                     
    43bc:	e12fff1e 	bx	lr                                             
                                                                      

00002e0c <rtems_termios_bufsize>: int cbufsize, int raw_input, int raw_output ) { rtems_termios_cbufsize = cbufsize;
    2e0c:	e59f3008 	ldr	r3, [pc, #8]	; 2e1c <rtems_termios_bufsize+0x10><== NOT EXECUTED
    2e10:	e8830007 	stm	r3, {r0, r1, r2}                              <== NOT EXECUTED
  rtems_termios_raw_input_size  = raw_input;                          
  rtems_termios_raw_output_size = raw_output;                         
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
    2e14:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    2e18:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00004204 <rtems_termios_close>: { rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    4204:	e59f2180 	ldr	r2, [pc, #384]	; 438c <rtems_termios_close+0x188>
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
	rtems_libio_open_close_args_t *args = arg;                           
	struct rtems_termios_tty *tty = args->iop->data1;                    
    4208:	e5903000 	ldr	r3, [r0]                                      
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    420c:	e3a01000 	mov	r1, #0                                        
	}                                                                    
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
    4210:	e92d4030 	push	{r4, r5, lr}                                 
    4214:	e1a05000 	mov	r5, r0                                        
	rtems_libio_open_close_args_t *args = arg;                           
	struct rtems_termios_tty *tty = args->iop->data1;                    
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    4218:	e5920000 	ldr	r0, [r2]                                      
    421c:	e1a02001 	mov	r2, r1                                        
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
	rtems_libio_open_close_args_t *args = arg;                           
	struct rtems_termios_tty *tty = args->iop->data1;                    
    4220:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    4224:	eb0003dc 	bl	519c <rtems_semaphore_obtain>                  
	if (sc != RTEMS_SUCCESSFUL)                                          
    4228:	e3500000 	cmp	r0, #0                                        
    422c:	1a000022 	bne	42bc <rtems_termios_close+0xb8>               
		rtems_fatal_error_occurred (sc);                                    
	if (--tty->refcount == 0) {                                          
    4230:	e5943008 	ldr	r3, [r4, #8]                                  
    4234:	e2433001 	sub	r3, r3, #1                                    
    4238:	e3530000 	cmp	r3, #0                                        
    423c:	e5843008 	str	r3, [r4, #8]                                  
    4240:	1a00004c 	bne	4378 <rtems_termios_close+0x174>              
                if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
    4244:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         
    4248:	e59f3140 	ldr	r3, [pc, #320]	; 4390 <rtems_termios_close+0x18c>
    424c:	e0833282 	add	r3, r3, r2, lsl #5                            
    4250:	e5931004 	ldr	r1, [r3, #4]                                  
    4254:	e3510000 	cmp	r1, #0                                        
    4258:	0a000003 	beq	426c <rtems_termios_close+0x68>               
			/*                                                                 
			 * call discipline-specific close                                  
			 */                                                                
			sc = rtems_termios_linesw[tty->t_line].l_close(tty);               
    425c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    4260:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    4264:	e12fff11 	bx	r1                                             <== NOT EXECUTED
    4268:	ea000006 	b	4288 <rtems_termios_close+0x84>                 <== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * default: just flush output buffer                               
			 */                                                                
			sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    426c:	e5940018 	ldr	r0, [r4, #24]                                 
    4270:	e1a02001 	mov	r2, r1                                        
    4274:	eb0003c8 	bl	519c <rtems_semaphore_obtain>                  
			if (sc != RTEMS_SUCCESSFUL) {                                      
    4278:	e3500000 	cmp	r0, #0                                        
    427c:	1a00000e 	bne	42bc <rtems_termios_close+0xb8>               
				rtems_fatal_error_occurred (sc);                                  
			}                                                                  
		        drainOutput (tty);                                          
    4280:	e1a00004 	mov	r0, r4                                        
    4284:	ebfffe05 	bl	3aa0 <drainOutput>                             
		}                                                                   
                                                                      
		if (tty->device.outputUsesInterrupts                                
    4288:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         
    428c:	e3530002 	cmp	r3, #2                                        
    4290:	1a00000a 	bne	42c0 <rtems_termios_close+0xbc>               
		    == TERMIOS_TASK_DRIVEN) {                                       
			/*                                                                 
			 * send "terminate" to I/O tasks                                   
			 */                                                                
			sc = rtems_event_send(                                             
    4294:	e59400c4 	ldr	r0, [r4, #196]	; 0xc4                         <== NOT EXECUTED
    4298:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    429c:	eb0002ab 	bl	4d50 <rtems_event_send>                        <== NOT EXECUTED
                                  tty->rxTaskId,                      
				  TERMIOS_RX_TERMINATE_EVENT);                                    
			if (sc != RTEMS_SUCCESSFUL)                                        
    42a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    42a4:	1a000004 	bne	42bc <rtems_termios_close+0xb8>               <== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
			sc = rtems_event_send(                                             
    42a8:	e59400c8 	ldr	r0, [r4, #200]	; 0xc8                         <== NOT EXECUTED
    42ac:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    42b0:	eb0002a6 	bl	4d50 <rtems_event_send>                        <== NOT EXECUTED
                                  tty->txTaskId,                      
				  TERMIOS_TX_TERMINATE_EVENT);                                    
			if (sc != RTEMS_SUCCESSFUL)                                        
    42b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    42b8:	0a000000 	beq	42c0 <rtems_termios_close+0xbc>               <== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
    42bc:	eb000539 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
		}                                                                   
		if (tty->device.lastClose)                                          
    42c0:	e594309c 	ldr	r3, [r4, #156]	; 0x9c                         
    42c4:	e3530000 	cmp	r3, #0                                        
			 (*tty->device.lastClose)(tty->major, tty->minor, arg);            
    42c8:	11a02005 	movne	r2, r5                                      
    42cc:	1284000c 	addne	r0, r4, #12                                 
    42d0:	18900003 	ldmne	r0, {r0, r1}                                
    42d4:	11a0e00f 	movne	lr, pc                                      
    42d8:	112fff13 	bxne	r3                                           
		if (tty->forw == NULL) {                                            
    42dc:	e894000c 	ldm	r4, {r2, r3}                                  
    42e0:	e3520000 	cmp	r2, #0                                        
			if ( rtems_termios_ttyTail != NULL ) {                             
				rtems_termios_ttyTail->forw = NULL;                               
			}                                                                  
		}                                                                   
		else {                                                              
			tty->forw->back = tty->back;                                       
    42e4:	15823004 	strne	r3, [r2, #4]                                
			if (sc != RTEMS_SUCCESSFUL)                                        
				rtems_fatal_error_occurred (sc);                                  
		}                                                                   
		if (tty->device.lastClose)                                          
			 (*tty->device.lastClose)(tty->major, tty->minor, arg);            
		if (tty->forw == NULL) {                                            
    42e8:	1a000003 	bne	42fc <rtems_termios_close+0xf8>               
			rtems_termios_ttyTail = tty->back;                                 
    42ec:	e59f10a0 	ldr	r1, [pc, #160]	; 4394 <rtems_termios_close+0x190>
			if ( rtems_termios_ttyTail != NULL ) {                             
    42f0:	e3530000 	cmp	r3, #0                                        
				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;                                 
    42f4:	e5813000 	str	r3, [r1]                                      
			if ( rtems_termios_ttyTail != NULL ) {                             
				rtems_termios_ttyTail->forw = NULL;                               
    42f8:	15832000 	strne	r2, [r3]                                    
			}                                                                  
		}                                                                   
		else {                                                              
			tty->forw->back = tty->back;                                       
		}                                                                   
		if (tty->back == NULL) {                                            
    42fc:	e5942004 	ldr	r2, [r4, #4]                                  
    4300:	e5943000 	ldr	r3, [r4]                                      
    4304:	e3520000 	cmp	r2, #0                                        
			if ( rtems_termios_ttyHead != NULL ) {                             
				rtems_termios_ttyHead->back = NULL;                               
			}                                                                  
		}                                                                   
		else {                                                              
			tty->back->forw = tty->forw;                                       
    4308:	15823000 	strne	r3, [r2]                                    
			}                                                                  
		}                                                                   
		else {                                                              
			tty->forw->back = tty->back;                                       
		}                                                                   
		if (tty->back == NULL) {                                            
    430c:	1a000003 	bne	4320 <rtems_termios_close+0x11c>              
			rtems_termios_ttyHead = tty->forw;                                 
    4310:	e59f1080 	ldr	r1, [pc, #128]	; 4398 <rtems_termios_close+0x194>
			if ( rtems_termios_ttyHead != NULL ) {                             
    4314:	e3530000 	cmp	r3, #0                                        
		}                                                                   
		else {                                                              
			tty->forw->back = tty->back;                                       
		}                                                                   
		if (tty->back == NULL) {                                            
			rtems_termios_ttyHead = tty->forw;                                 
    4318:	e5813000 	str	r3, [r1]                                      
			if ( rtems_termios_ttyHead != NULL ) {                             
				rtems_termios_ttyHead->back = NULL;                               
    431c:	15832004 	strne	r2, [r3, #4]                                
			}                                                                  
		}                                                                   
		else {                                                              
			tty->back->forw = tty->forw;                                       
		}                                                                   
		rtems_semaphore_delete (tty->isem);                                 
    4320:	e5940014 	ldr	r0, [r4, #20]                                 
    4324:	eb000375 	bl	5100 <rtems_semaphore_delete>                  
		rtems_semaphore_delete (tty->osem);                                 
    4328:	e5940018 	ldr	r0, [r4, #24]                                 
    432c:	eb000373 	bl	5100 <rtems_semaphore_delete>                  
		rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                  
    4330:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         
    4334:	eb000371 	bl	5100 <rtems_semaphore_delete>                  
		if ((tty->device.pollRead == NULL) ||                               
    4338:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         
    433c:	e3530000 	cmp	r3, #0                                        
    4340:	0a000002 	beq	4350 <rtems_termios_close+0x14c>              
		    (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))      
    4344:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         
    4348:	e3530002 	cmp	r3, #2                                        
    434c:	1a000001 	bne	4358 <rtems_termios_close+0x154>              
			rtems_semaphore_delete (tty->rawInBuf.Semaphore);                  
    4350:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
    4354:	eb000369 	bl	5100 <rtems_semaphore_delete>                  <== NOT EXECUTED
		free (tty->rawInBuf.theBuf);                                        
    4358:	e5940058 	ldr	r0, [r4, #88]	; 0x58                          
    435c:	ebfff6db 	bl	1ed0 <free>                                    
		free (tty->rawOutBuf.theBuf);                                       
    4360:	e594007c 	ldr	r0, [r4, #124]	; 0x7c                         
    4364:	ebfff6d9 	bl	1ed0 <free>                                    
		free (tty->cbuf);                                                   
    4368:	e594001c 	ldr	r0, [r4, #28]                                 
    436c:	ebfff6d7 	bl	1ed0 <free>                                    
		free (tty);                                                         
    4370:	e1a00004 	mov	r0, r4                                        
    4374:	ebfff6d5 	bl	1ed0 <free>                                    
	}                                                                    
	rtems_semaphore_release (rtems_termios_ttyMutex);                    
    4378:	e59f300c 	ldr	r3, [pc, #12]	; 438c <rtems_termios_close+0x188>
    437c:	e5930000 	ldr	r0, [r3]                                      
    4380:	eb0003cb 	bl	52b4 <rtems_semaphore_release>                 
	return RTEMS_SUCCESSFUL;                                             
}                                                                     
    4384:	e3a00000 	mov	r0, #0                                        
    4388:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

00003008 <rtems_termios_dequeue_characters>: rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len;
    3008:	e590c090 	ldr	ip, [r0, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {       
    300c:	e59020b4 	ldr	r2, [r0, #180]	; 0xb4                         <== NOT EXECUTED
	rtems_status_code sc;                                                
                                                                      
	/*                                                                   
	 * sum up character count already sent                               
	 */                                                                  
	tty->t_dqlen += len;                                                 
    3010:	e08c1001 	add	r1, ip, r1                                    <== NOT EXECUTED
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {       
    3014:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
 * for each transmitted character.                                    
 * It returns number of characters left to transmit                   
 */                                                                   
int                                                                   
rtems_termios_dequeue_characters (void *ttyp, int len)                
{                                                                     
    3018:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
	rtems_status_code sc;                                                
                                                                      
	/*                                                                   
	 * sum up character count already sent                               
	 */                                                                  
	tty->t_dqlen += len;                                                 
    301c:	e5801090 	str	r1, [r0, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {       
    3020:	1a000005 	bne	303c <rtems_termios_dequeue_characters+0x34>  <== NOT EXECUTED
		/*                                                                  
		 * send wake up to transmitter task                                 
		 */                                                                 
		sc = rtems_event_send(tty->txTaskId,                                
    3024:	e59000c8 	ldr	r0, [r0, #200]	; 0xc8                         <== NOT EXECUTED
    3028:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
    302c:	eb000747 	bl	4d50 <rtems_event_send>                        <== NOT EXECUTED
				      TERMIOS_TX_START_EVENT);                                    
		if (sc != RTEMS_SUCCESSFUL)                                         
    3030:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    3034:	0a00000c 	beq	306c <rtems_termios_dequeue_characters+0x64>  <== NOT EXECUTED
			rtems_fatal_error_occurred (sc);                                   
    3038:	eb0009da 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
		return 0; /* nothing to output in IRQ... */                         
	}                                                                    
	else if (tty->t_line == PPPDISC ) {                                  
    303c:	e59030cc 	ldr	r3, [r0, #204]	; 0xcc                         <== NOT EXECUTED
    3040:	e3530005 	cmp	r3, #5                                        <== NOT EXECUTED
    3044:	1a000006 	bne	3064 <rtems_termios_dequeue_characters+0x5c>  <== NOT EXECUTED
		/*                                                                  
		 * call any line discipline start function                          
		 */                                                                 
		if (rtems_termios_linesw[tty->t_line].l_start != NULL) {            
    3048:	e59f3024 	ldr	r3, [pc, #36]	; 3074 <rtems_termios_dequeue_characters+0x6c><== NOT EXECUTED
    304c:	e59330b4 	ldr	r3, [r3, #180]	; 0xb4                         <== NOT EXECUTED
    3050:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3054:	0a000004 	beq	306c <rtems_termios_dequeue_characters+0x64>  <== NOT EXECUTED
			rtems_termios_linesw[tty->t_line].l_start(tty);                    
    3058:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    305c:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    3060:	ea000001 	b	306c <rtems_termios_dequeue_characters+0x64>    <== NOT EXECUTED
		return 0; /* nothing to output in IRQ... */                         
	}                                                                    
	else {                                                               
		return rtems_termios_refill_transmitter(tty);                       
	}                                                                    
}                                                                     
    3064:	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... */                         
	}                                                                    
	else {                                                               
		return rtems_termios_refill_transmitter(tty);                       
    3068:	eaffff6f 	b	2e2c <rtems_termios_refill_transmitter>         <== NOT EXECUTED
	}                                                                    
}                                                                     
    306c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    3070:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00003078 <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) {
    3078:	e92d4ff7 	push	{r0, r1, r2, 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) {              
    307c:	e59f32b8 	ldr	r3, [pc, #696]	; 333c <rtems_termios_enqueue_raw_characters+0x2c4><== 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) 
{                                                                     
    3080:	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) {              
    3084:	e59000cc 	ldr	r0, [r0, #204]	; 0xcc                         <== NOT EXECUTED
    3088:	e0830280 	add	r0, r3, r0, lsl #5                            <== NOT EXECUTED
    308c:	e5906010 	ldr	r6, [r0, #16]                                 <== NOT EXECUTED
    3090:	e3560000 	cmp	r6, #0                                        <== 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) 
{                                                                     
    3094:	e1a0b001 	mov	fp, r1                                        <== 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);      
    3098:	11a05002 	movne	r5, r2                                      <== NOT EXECUTED
	rtems_interrupt_level level;                                         
                                                                      
	if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {              
	  while (len--) {                                                    
	    c = *buf++;                                                      
	    rtems_termios_linesw[tty->t_line].l_rint(c,tty);                 
    309c:	11a07003 	movne	r7, r3                                      <== 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);      
    30a0:	13a06000 	movne	r6, #0                                      <== 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) {              
    30a4:	1a00000e 	bne	30e4 <rtems_termios_enqueue_raw_characters+0x6c><== 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);      
    30a8:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
    30ac:	e2843030 	add	r3, r4, #48	; 0x30                            <== 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,                              
    30b0:	e284204a 	add	r2, r4, #74	; 0x4a                            <== NOT EXECUTED
    30b4:	e58d2008 	str	r2, [sp, #8]                                  <== 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);      
    30b8:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
    30bc:	e1a09006 	mov	r9, r6                                        <== NOT EXECUTED
    30c0:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
    30c4:	ea000091 	b	3310 <rtems_termios_enqueue_raw_characters+0x298><== NOT EXECUTED
	rtems_interrupt_level level;                                         
                                                                      
	if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {              
	  while (len--) {                                                    
	    c = *buf++;                                                      
	    rtems_termios_linesw[tty->t_line].l_rint(c,tty);                 
    30c8:	e59430cc 	ldr	r3, [r4, #204]	; 0xcc                         <== NOT EXECUTED
    30cc:	e7db0006 	ldrb	r0, [fp, r6]                                 <== NOT EXECUTED
    30d0:	e0873283 	add	r3, r7, r3, lsl #5                            <== NOT EXECUTED
    30d4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    30d8:	e593f010 	ldr	pc, [r3, #16]                                 <== NOT EXECUTED
    30dc:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
    30e0:	e2455001 	sub	r5, r5, #1                                    <== 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--) {                                                    
    30e4:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
	    c = *buf++;                                                      
	    rtems_termios_linesw[tty->t_line].l_rint(c,tty);                 
    30e8:	e1a01004 	mov	r1, r4                                        <== 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--) {                                                    
    30ec:	1afffff5 	bne	30c8 <rtems_termios_enqueue_raw_characters+0x50><== NOT EXECUTED
	  }                                                                  
                                                                      
	  /*                                                                 
	   * check to see if rcv wakeup callback was set                     
	   */                                                                
	  if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {  
    30f0:	e59430e4 	ldr	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
    30f4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    30f8:	1a00008c 	bne	3330 <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
    30fc:	e59430dc 	ldr	r3, [r4, #220]	; 0xdc                         <== NOT EXECUTED
    3100:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3104:	0a000089 	beq	3330 <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
	    (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);      
    3108:	e2840030 	add	r0, r4, #48	; 0x30                            <== NOT EXECUTED
    310c:	e59410e0 	ldr	r1, [r4, #224]	; 0xe0                         <== NOT EXECUTED
    3110:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3114:	e12fff13 	bx	r3                                             <== NOT EXECUTED
	    tty->tty_rcvwakeup = 1;                                          
    3118:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    311c:	e58430e4 	str	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
    3120:	ea000083 	b	3334 <rtems_termios_enqueue_raw_characters+0x2bc><== NOT EXECUTED
                                                                      
	while (len--) {                                                      
	  c = *buf++;                                                        
	  /* FIXME: implement IXANY: any character restarts output */        
	  /* if incoming XON/XOFF controls outgoing stream: */               
	  if (tty->flow_ctrl & FL_MDXON) {                                   
    3124:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3128:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
    	  }                                                              
	  return 0;                                                          
	}                                                                    
                                                                      
	while (len--) {                                                      
	  c = *buf++;                                                        
    312c:	e7dba006 	ldrb	sl, [fp, r6]                                 <== NOT EXECUTED
	  /* FIXME: implement IXANY: any character restarts output */        
	  /* if incoming XON/XOFF controls outgoing stream: */               
	  if (tty->flow_ctrl & FL_MDXON) {                                   
    3130:	0a00000f 	beq	3174 <rtems_termios_enqueue_raw_characters+0xfc><== NOT EXECUTED
	    /* if received char is V_STOP and V_START (both are equal value) */
	    if (c == tty->termios.c_cc[VSTOP]) {                             
    3134:	e5d4204a 	ldrb	r2, [r4, #74]	; 0x4a                         <== NOT EXECUTED
    3138:	e152000a 	cmp	r2, sl                                        <== NOT EXECUTED
    313c:	e5d43049 	ldrb	r3, [r4, #73]	; 0x49                         <== NOT EXECUTED
    3140:	1a000007 	bne	3164 <rtems_termios_enqueue_raw_characters+0xec><== NOT EXECUTED
	      if (c == tty->termios.c_cc[VSTART]) {                          
    3144:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
		/* received VSTOP and VSTART==VSTOP? */                             
		/* then toggle "stop output" status  */                             
		tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;                       
    3148:	059430b8 	ldreq	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
	      }                                                              
	      else {                                                         
		/* VSTOP received (other code than VSTART) */                       
		/* stop output                             */                       
		tty->flow_ctrl |= FL_ORCVXOF;                                       
    314c:	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;                       
    3150:	02233010 	eoreq	r3, r3, #16                                 <== NOT EXECUTED
	      }                                                              
	      else {                                                         
		/* VSTOP received (other code than VSTART) */                       
		/* stop output                             */                       
		tty->flow_ctrl |= FL_ORCVXOF;                                       
    3154:	13833010 	orrne	r3, r3, #16                                 <== NOT EXECUTED
    3158:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		}                                                                   
	  }                                                                  
	}                                                                    
	tty->rawInBufDropped += dropped;                                     
	rtems_semaphore_release (tty->rawInBuf.Semaphore);                   
	return dropped;                                                      
    315c:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
    3160:	ea000005 	b	317c <rtems_termios_enqueue_raw_characters+0x104><== NOT EXECUTED
		/* stop output                             */                       
		tty->flow_ctrl |= FL_ORCVXOF;                                       
	      }                                                              
	      flow_rcv = true;                                               
	    }                                                                
	    else if (c == tty->termios.c_cc[VSTART]) {                       
    3164:	e153000a 	cmp	r3, sl                                        <== NOT EXECUTED
	      /* VSTART received */                                          
	      /* restart output  */                                          
	      tty->flow_ctrl &= ~FL_ORCVXOF;                                 
    3168:	059430b8 	ldreq	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
    316c:	03c33010 	biceq	r3, r3, #16                                 <== NOT EXECUTED
		/* stop output                             */                       
		tty->flow_ctrl |= FL_ORCVXOF;                                       
	      }                                                              
	      flow_rcv = true;                                               
	    }                                                                
	    else if (c == tty->termios.c_cc[VSTART]) {                       
    3170:	0afffff8 	beq	3158 <rtems_termios_enqueue_raw_characters+0xe0><== NOT EXECUTED
	      /* restart output  */                                          
	      tty->flow_ctrl &= ~FL_ORCVXOF;                                 
	      flow_rcv = true;                                               
	    }                                                                
	  }                                                                  
	  if (flow_rcv) {                                                    
    3174:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
    3178:	0a000015 	beq	31d4 <rtems_termios_enqueue_raw_characters+0x15c><== NOT EXECUTED
	    /* restart output according to FL_ORCVXOF flag */                
	    if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {    
    317c:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3180:	e2033030 	and	r3, r3, #48	; 0x30                            <== NOT EXECUTED
    3184:	e3530020 	cmp	r3, #32                                       <== NOT EXECUTED
    3188:	1a00005e 	bne	3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    318c:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
    3190:	e3873080 	orr	r3, r7, #128	; 0x80                           <== NOT EXECUTED
    3194:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
	      /* disable interrupts    */                                    
	      rtems_interrupt_disable(level);                                
	      tty->flow_ctrl &= ~FL_OSTOP;                                   
    3198:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
	      /* check for chars in output buffer (or rob_state?) */         
	      if (tty->rawOutBufState != rob_idle) {                         
    319c:	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;                                   
    31a0:	e3c33020 	bic	r3, r3, #32                                   <== NOT EXECUTED
	      /* check for chars in output buffer (or rob_state?) */         
	      if (tty->rawOutBufState != rob_idle) {                         
    31a4:	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;                                   
    31a8:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
	      /* check for chars in output buffer (or rob_state?) */         
	      if (tty->rawOutBufState != rob_idle) {                         
    31ac:	0a000006 	beq	31cc <rtems_termios_enqueue_raw_characters+0x154><== NOT EXECUTED
	      /* if chars available, call write function... */               
		(*tty->device.write)(tty->minor,                                    
		     &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);               
    31b0:	e5943084 	ldr	r3, [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)(tty->minor,                                    
    31b4:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
    31b8:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    31bc:	e0811003 	add	r1, r1, r3                                    <== NOT EXECUTED
    31c0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    31c4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    31c8:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    31cc:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
    31d0:	ea00004c 	b	3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
	      /* reenable interrupts */                                      
	      rtems_interrupt_enable(level);                                 
	    }                                                                
	  }                                                                  
	  else {                                                             
		newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;            
    31d4:	e5940060 	ldr	r0, [r4, #96]	; 0x60                          <== NOT EXECUTED
    31d8:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
    31dc:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
    31e0:	eb004e95 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    31e4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    31e8:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
    31ec:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
    31f0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    31f4:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
		/* if chars_in_buffer > highwater                */                 
		rtems_interrupt_disable(level);                                     
		if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)           
    31f8:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    31fc:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
    3200:	e0630000 	rsb	r0, r3, r0                                    <== NOT EXECUTED
    3204:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
    3208:	e0800007 	add	r0, r0, r7                                    <== NOT EXECUTED
    320c:	eb004e8a 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
		      % tty->rawInBuf.Size)                                         
		     > tty->highwater) &&                                           
    3210:	e59430c0 	ldr	r3, [r4, #192]	; 0xc0                         <== NOT EXECUTED
    3214:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    3218:	9a000025 	bls	32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
		    !(tty->flow_ctrl & FL_IREQXOF)) {                               
    321c:	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)           
    3220:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
    3224:	1a000022 	bne	32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
		      % tty->rawInBuf.Size)                                         
		     > tty->highwater) &&                                           
		    !(tty->flow_ctrl & FL_IREQXOF)) {                               
		  /* incoming data stream should be stopped */                      
		  tty->flow_ctrl |= FL_IREQXOF;                                     
    3228:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    322c:	e3833001 	orr	r3, r3, #1                                    <== NOT EXECUTED
    3230:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		  if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                    
    3234:	e59f3104 	ldr	r3, [pc, #260]	; 3340 <rtems_termios_enqueue_raw_characters+0x2c8><== NOT EXECUTED
    3238:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    323c:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
    3240:	e3530b01 	cmp	r3, #1024	; 0x400                             <== NOT EXECUTED
    3244:	1a00000e 	bne	3284 <rtems_termios_enqueue_raw_characters+0x20c><== NOT EXECUTED
		      ==                (FL_MDXOF             ) ){                  
		    if ((tty->flow_ctrl & FL_OSTOP) ||                              
    3248:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    324c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
    3250:	1a000002 	bne	3260 <rtems_termios_enqueue_raw_characters+0x1e8><== NOT EXECUTED
			(tty->rawOutBufState == rob_idle)) {                               
    3254:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
    3258:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    325c:	1a000014 	bne	32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
		      /* if tx is stopped due to XOFF or out of data */             
		      /*    call write function here                 */             
		      tty->flow_ctrl |= FL_ISNTXOF;                                 
    3260:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3264:	e3833002 	orr	r3, r3, #2                                    <== NOT EXECUTED
    3268:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		      (*tty->device.write)(tty->minor,                              
    326c:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    3270:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
    3274:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    3278:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    327c:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
    3280:	ea00000b 	b	32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
			 (void *)&(tty->termios.c_cc[VSTOP]),                              
			 1);                                                               
		    }                                                               
		  }                                                                 
		  else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))               
    3284:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3288:	e2033f41 	and	r3, r3, #260	; 0x104                          <== NOT EXECUTED
    328c:	e3530c01 	cmp	r3, #256	; 0x100                              <== NOT EXECUTED
    3290:	1a000007 	bne	32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
			   ==                (FL_MDRTS             ) ) {                   
		    tty->flow_ctrl |= FL_IRTSOFF;                                   
    3294:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		    /* deactivate RTS line */                                       
		    if (tty->device.stopRemoteTx != NULL) {                         
    3298:	e59430ac 	ldr	r3, [r4, #172]	; 0xac                         <== NOT EXECUTED
			 1);                                                               
		    }                                                               
		  }                                                                 
		  else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))               
			   ==                (FL_MDRTS             ) ) {                   
		    tty->flow_ctrl |= FL_IRTSOFF;                                   
    329c:	e3822004 	orr	r2, r2, #4                                    <== NOT EXECUTED
		    /* deactivate RTS line */                                       
		    if (tty->device.stopRemoteTx != NULL) {                         
    32a0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
			 1);                                                               
		    }                                                               
		  }                                                                 
		  else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))               
			   ==                (FL_MDRTS             ) ) {                   
		    tty->flow_ctrl |= FL_IRTSOFF;                                   
    32a4:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		    /* deactivate RTS line */                                       
		    if (tty->device.stopRemoteTx != NULL) {                         
		      tty->device.stopRemoteTx(tty->minor);                         
    32a8:	15940010 	ldrne	r0, [r4, #16]                               <== NOT EXECUTED
    32ac:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    32b0:	112fff13 	bxne	r3                                           <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    32b4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    32b8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
		  }                                                                 
		}                                                                   
		/* reenable interrupts */                                           
		rtems_interrupt_enable(level);                                      
                                                                      
		if (newTail == tty->rawInBuf.Head) {                                
    32bc:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    32c0:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
		        dropped++;                                                  
    32c4:	02855001 	addeq	r5, r5, #1                                  <== NOT EXECUTED
		  }                                                                 
		}                                                                   
		/* reenable interrupts */                                           
		rtems_interrupt_enable(level);                                      
                                                                      
		if (newTail == tty->rawInBuf.Head) {                                
    32c8:	0a00000e 	beq	3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
		        dropped++;                                                  
		}                                                                   
		else {                                                              
		        tty->rawInBuf.theBuf[newTail] = c;                          
    32cc:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
    32d0:	e7c3a007 	strb	sl, [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 )) {  
    32d4:	e59430e4 	ldr	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
    32d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
		if (newTail == tty->rawInBuf.Head) {                                
		        dropped++;                                                  
		}                                                                   
		else {                                                              
		        tty->rawInBuf.theBuf[newTail] = c;                          
		        tty->rawInBuf.Tail = newTail;                               
    32dc:	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 )) {  
    32e0:	1a000008 	bne	3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
    32e4:	e59430dc 	ldr	r3, [r4, #220]	; 0xdc                         <== NOT EXECUTED
    32e8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    32ec:	0a000005 	beq	3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
			  (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);      
    32f0:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
    32f4:	e59410e0 	ldr	r1, [r4, #224]	; 0xe0                         <== NOT EXECUTED
    32f8:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    32fc:	e12fff13 	bx	r3                                             <== NOT EXECUTED
			  tty->tty_rcvwakeup = 1;                                          
    3300:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    3304:	e58420e4 	str	r2, [r4, #228]	; 0xe4                         <== NOT EXECUTED
    3308:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
    330c:	e2488001 	sub	r8, r8, #1                                    <== NOT EXECUTED
	    tty->tty_rcvwakeup = 1;                                          
    	  }                                                              
	  return 0;                                                          
	}                                                                    
                                                                      
	while (len--) {                                                      
    3310:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
    3314:	1affff82 	bne	3124 <rtems_termios_enqueue_raw_characters+0xac><== NOT EXECUTED
			  tty->tty_rcvwakeup = 1;                                          
			}                                                                  
		}                                                                   
	  }                                                                  
	}                                                                    
	tty->rawInBufDropped += dropped;                                     
    3318:	e5943078 	ldr	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
    331c:	e0833005 	add	r3, r3, r5                                    <== NOT EXECUTED
    3320:	e5843078 	str	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
	rtems_semaphore_release (tty->rawInBuf.Semaphore);                   
    3324:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
    3328:	eb0007e1 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
	return dropped;                                                      
    332c:	ea000000 	b	3334 <rtems_termios_enqueue_raw_characters+0x2bc><== NOT EXECUTED
    3330:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
}                                                                     
    3334:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    3338:	e8bd8ffe 	pop	{r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
                                                                      

00003e5c <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;
    3e5c:	e5903000 	ldr	r3, [r0]                                      
	struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer; 
	rtems_status_code sc;                                                
                                                                      
 	args->ioctl_return = 0;                                             
    3e60:	e3a01000 	mov	r1, #0                                        
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
    3e64:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
	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;                                             
    3e68:	e580100c 	str	r1, [r0, #12]                                 
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
	rtems_libio_ioctl_args_t *args = arg;                                
	struct rtems_termios_tty *tty = args->iop->data1;                    
    3e6c:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
    3e70:	e1a05000 	mov	r5, r0                                        
	struct rtems_termios_tty *tty = args->iop->data1;                    
	struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer; 
	rtems_status_code sc;                                                
                                                                      
 	args->ioctl_return = 0;                                             
	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    3e74:	e1a02001 	mov	r2, r1                                        
    3e78:	e5940018 	ldr	r0, [r4, #24]                                 
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; 
    3e7c:	e5957008 	ldr	r7, [r5, #8]                                  
	rtems_status_code sc;                                                
                                                                      
 	args->ioctl_return = 0;                                             
	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    3e80:	eb0004c5 	bl	519c <rtems_semaphore_obtain>                  
	if (sc != RTEMS_SUCCESSFUL) {                                        
    3e84:	e2506000 	subs	r6, r0, #0                                   
    3e88:	1a0000d7 	bne	41ec <rtems_termios_ioctl+0x390>              
		args->ioctl_return = sc;                                            
		return sc;                                                          
	}                                                                    
	switch (args->command) {                                             
    3e8c:	e5953004 	ldr	r3, [r5, #4]                                  
    3e90:	e3530004 	cmp	r3, #4                                        
    3e94:	0a0000ab 	beq	4148 <rtems_termios_ioctl+0x2ec>              
    3e98:	8a000005 	bhi	3eb4 <rtems_termios_ioctl+0x58>               
    3e9c:	e3530002 	cmp	r3, #2                                        
    3ea0:	0a000029 	beq	3f4c <rtems_termios_ioctl+0xf0>               
    3ea4:	8a0000a0 	bhi	412c <rtems_termios_ioctl+0x2d0>              
    3ea8:	e3530001 	cmp	r3, #1                                        
    3eac:	1a000010 	bne	3ef4 <rtems_termios_ioctl+0x98>               
    3eb0:	ea00001b 	b	3f24 <rtems_termios_ioctl+0xc8>                 
    3eb4:	e59f233c 	ldr	r2, [pc, #828]	; 41f8 <rtems_termios_ioctl+0x39c><== NOT EXECUTED
    3eb8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
    3ebc:	0a0000bd 	beq	41b8 <rtems_termios_ioctl+0x35c>              <== NOT EXECUTED
    3ec0:	8a000002 	bhi	3ed0 <rtems_termios_ioctl+0x74>               <== NOT EXECUTED
    3ec4:	e3530005 	cmp	r3, #5                                        <== NOT EXECUTED
    3ec8:	1a000009 	bne	3ef4 <rtems_termios_ioctl+0x98>               <== NOT EXECUTED
    3ecc:	ea000099 	b	4138 <rtems_termios_ioctl+0x2dc>                <== NOT EXECUTED
    3ed0:	e59f2324 	ldr	r2, [pc, #804]	; 41fc <rtems_termios_ioctl+0x3a0><== NOT EXECUTED
    3ed4:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
		if (rtems_termios_linesw[tty->t_line].l_open != NULL) {             
			sc = rtems_termios_linesw[tty->t_line].l_open(tty);                
		}                                                                   
		break;                                                              
	case TIOCGETD:                                                       
		*(int*)(args->buffer)=tty->t_line;                                  
    3ed8:	05953008 	ldreq	r3, [r5, #8]                                <== NOT EXECUTED
    3edc:	059420cc 	ldreq	r2, [r4, #204]	; 0xcc                       <== NOT EXECUTED
    3ee0:	05832000 	streq	r2, [r3]                                    <== 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) {                                             
    3ee4:	0a0000be 	beq	41e4 <rtems_termios_ioctl+0x388>              <== NOT EXECUTED
    3ee8:	e2822105 	add	r2, r2, #1073741825	; 0x40000001              <== NOT EXECUTED
    3eec:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
    3ef0:	0a000098 	beq	4158 <rtems_termios_ioctl+0x2fc>              <== NOT EXECUTED
	default:                                                             
		if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {            
    3ef4:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         <== NOT EXECUTED
    3ef8:	e59f3300 	ldr	r3, [pc, #768]	; 4200 <rtems_termios_ioctl+0x3a4><== NOT EXECUTED
    3efc:	e0833282 	add	r3, r3, r2, lsl #5                            <== NOT EXECUTED
    3f00:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
    3f04:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3f08:	03a0600a 	moveq	r6, #10                                     <== NOT EXECUTED
    3f0c:	0a0000b4 	beq	41e4 <rtems_termios_ioctl+0x388>              <== NOT EXECUTED
			sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);          
    3f10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    3f14:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    3f18:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3f1c:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    3f20:	ea0000a2 	b	41b0 <rtems_termios_ioctl+0x354>                <== NOT EXECUTED
			sc = RTEMS_INVALID_NUMBER;                                         
		}                                                                   
		break;                                                              
                                                                      
	case RTEMS_IO_GET_ATTRIBUTES:                                        
		*(struct termios *)args->buffer = tty->termios;                     
    3f24:	e5957008 	ldr	r7, [r5, #8]                                  
    3f28:	e284c030 	add	ip, r4, #48	; 0x30                            
    3f2c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         
    3f30:	e1a0e007 	mov	lr, r7                                        
    3f34:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       
    3f38:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         
    3f3c:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       
    3f40:	e59c3000 	ldr	r3, [ip]                                      
    3f44:	e58e3000 	str	r3, [lr]                                      
		break;                                                              
    3f48:	ea0000a5 	b	41e4 <rtems_termios_ioctl+0x388>                
                                                                      
	case RTEMS_IO_SET_ATTRIBUTES:                                        
		tty->termios = *(struct termios *)args->buffer;                     
    3f4c:	e595e008 	ldr	lr, [r5, #8]                                  
    3f50:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    3f54:	e284c030 	add	ip, r4, #48	; 0x30                            
    3f58:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    3f5c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    3f60:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
    3f64:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         
	case RTEMS_IO_GET_ATTRIBUTES:                                        
		*(struct termios *)args->buffer = tty->termios;                     
		break;                                                              
                                                                      
	case RTEMS_IO_SET_ATTRIBUTES:                                        
		tty->termios = *(struct termios *)args->buffer;                     
    3f68:	e59e3000 	ldr	r3, [lr]                                      
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
    3f6c:	e3120c02 	tst	r2, #512	; 0x200                              
	case RTEMS_IO_GET_ATTRIBUTES:                                        
		*(struct termios *)args->buffer = tty->termios;                     
		break;                                                              
                                                                      
	case RTEMS_IO_SET_ATTRIBUTES:                                        
		tty->termios = *(struct termios *)args->buffer;                     
    3f70:	e58c3000 	str	r3, [ip]                                      
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
    3f74:	0a000019 	beq	3fe0 <rtems_termios_ioctl+0x184>              
    3f78:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          
    3f7c:	e3130b01 	tst	r3, #1024	; 0x400                             
    3f80:	1a000016 	bne	3fe0 <rtems_termios_ioctl+0x184>              
      !(tty->termios.c_iflag & IXON)) {                               
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);                       
    3f84:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3f88:	e3c33e21 	bic	r3, r3, #528	; 0x210                          <== NOT EXECUTED
    3f8c:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
    3f90:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3f94:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
    3f98:	0a000010 	beq	3fe0 <rtems_termios_ioctl+0x184>              <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    3f9c:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
    3fa0:	e3873080 	orr	r3, r7, #128	; 0x80                           <== NOT EXECUTED
    3fa4:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl &= ~FL_OSTOP;                                    
    3fa8:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
    3fac:	e5942094 	ldr	r2, [r4, #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;                                    
    3fb0:	e3c33020 	bic	r3, r3, #32                                   <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
    3fb4:	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;                                    
    3fb8:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
    3fbc:	0a000006 	beq	3fdc <rtems_termios_ioctl+0x180>              <== NOT EXECUTED
	/* if chars available, call write function... */                     
	(*tty->device.write)(tty->minor,                                     
		     &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);                
    3fc0:	e5943084 	ldr	r3, [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)(tty->minor,                                     
    3fc4:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
    3fc8:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    3fcc:	e0811003 	add	r1, r1, r3                                    <== NOT EXECUTED
    3fd0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    3fd4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3fd8:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    3fdc:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
    }                                                                 
  }                                                                   
  /* check for incoming XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXOF) &&                                 
    3fe0:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         
    3fe4:	e3130b01 	tst	r3, #1024	; 0x400                             
    3fe8:	0a000008 	beq	4010 <rtems_termios_ioctl+0x1b4>              
    3fec:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
    3ff0:	e3130a01 	tst	r3, #4096	; 0x1000                            <== NOT EXECUTED
    3ff4:	1a000005 	bne	4010 <rtems_termios_ioctl+0x1b4>              <== NOT EXECUTED
      !(tty->termios.c_iflag & IXOFF)) {                              
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXOF);                                    
    3ff8:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3ffc:	e3c33b01 	bic	r3, r3, #1024	; 0x400                         <== NOT EXECUTED
    4000:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    /* FIXME: what happens, if we had sent XOFF but not yet XON? */   
    tty->flow_ctrl &= ~(FL_ISNTXOF);                                  
    4004:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    4008:	e3c33002 	bic	r3, r3, #2                                    <== NOT EXECUTED
    400c:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /* check for incoming RTS/CTS flow control switched off */          
  if (( tty->flow_ctrl & FL_MDRTS) &&                                 
    4010:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         
    4014:	e3130c01 	tst	r3, #256	; 0x100                              
    4018:	0a000010 	beq	4060 <rtems_termios_ioctl+0x204>              
    401c:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
    4020:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    4024:	ba00000d 	blt	4060 <rtems_termios_ioctl+0x204>              <== NOT EXECUTED
      !(tty->termios.c_cflag & CRTSCTS)) {                            
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
    4028:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    402c:	e3c33c01 	bic	r3, r3, #256	; 0x100                          <== NOT EXECUTED
    4030:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
    /* restart remote Tx, if it was stopped */                        
    if ((tty->flow_ctrl & FL_IRTSOFF) &&                              
    4034:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    4038:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
    403c:	0a000004 	beq	4054 <rtems_termios_ioctl+0x1f8>              <== NOT EXECUTED
	(tty->device.startRemoteTx != NULL)) {                               
    4040:	e59430b0 	ldr	r3, [r4, #176]	; 0xb0                         <== NOT EXECUTED
      !(tty->termios.c_cflag & CRTSCTS)) {                            
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
                                                                      
    /* restart remote Tx, if it was stopped */                        
    if ((tty->flow_ctrl & FL_IRTSOFF) &&                              
    4044:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
	(tty->device.startRemoteTx != NULL)) {                               
      tty->device.startRemoteTx(tty->minor);                          
    4048:	15940010 	ldrne	r0, [r4, #16]                               <== NOT EXECUTED
    404c:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    4050:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    }                                                                 
    tty->flow_ctrl &= ~(FL_IRTSOFF);                                  
    4054:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    4058:	e3c33004 	bic	r3, r3, #4                                    <== NOT EXECUTED
    405c:	e58430b8 	str	r3, [r4, #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) {                               
    4060:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          
    4064:	e3530000 	cmp	r3, #0                                        
    tty->flow_ctrl |= FL_MDRTS;                                       
    4068:	b59430b8 	ldrlt	r3, [r4, #184]	; 0xb8                       
    406c:	b3833c01 	orrlt	r3, r3, #256	; 0x100                        
    4070:	b58430b8 	strlt	r3, [r4, #184]	; 0xb8                       
  }                                                                   
  /* check for incoming XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXOFF) {                                 
    4074:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          
    4078:	e3130a01 	tst	r3, #4096	; 0x1000                            
    tty->flow_ctrl |= FL_MDXOF;                                       
    407c:	159430b8 	ldrne	r3, [r4, #184]	; 0xb8                       
    4080:	13833b01 	orrne	r3, r3, #1024	; 0x400                       
    4084:	158430b8 	strne	r3, [r4, #184]	; 0xb8                       
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
    4088:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          
    408c:	e3130b01 	tst	r3, #1024	; 0x400                             
    tty->flow_ctrl |= FL_MDXON;                                       
    4090:	159430b8 	ldrne	r3, [r4, #184]	; 0xb8                       
		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) {                                
    4094:	e594703c 	ldr	r7, [r4, #60]	; 0x3c                          
  if (tty->termios.c_iflag & IXOFF) {                                 
    tty->flow_ctrl |= FL_MDXOF;                                       
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
    tty->flow_ctrl |= FL_MDXON;                                       
    4098:	13833c02 	orrne	r3, r3, #512	; 0x200                        
    409c:	158430b8 	strne	r3, [r4, #184]	; 0xb8                       
		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) {                                
    40a0:	e2177002 	ands	r7, r7, #2                                   
			tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                        
    40a4:	13a03000 	movne	r3, #0                                      
		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) {                                
    40a8:	1a000014 	bne	4100 <rtems_termios_ioctl+0x2a4>              
			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;             
    40ac:	e5d48046 	ldrb	r8, [r4, #70]	; 0x46                         
    40b0:	eb0002a5 	bl	4b4c <rtems_clock_get_ticks_per_second>        
			tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                        
			tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                  
			tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;             
		}                                                                   
		else {                                                              
			tty->vtimeTicks = tty->termios.c_cc[VTIME] *                       
    40b4:	e3a0100a 	mov	r1, #10                                       
    40b8:	e0000098 	mul	r0, r8, r0                                    
    40bc:	eb004a4a 	bl	169ec <__aeabi_uidiv>                          
			              rtems_clock_get_ticks_per_second() / 10;             
			if (tty->termios.c_cc[VTIME]) {                                    
    40c0:	e5d43046 	ldrb	r3, [r4, #70]	; 0x46                         
    40c4:	e3530000 	cmp	r3, #0                                        
			tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                        
			tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                  
			tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;             
		}                                                                   
		else {                                                              
			tty->vtimeTicks = tty->termios.c_cc[VTIME] *                       
    40c8:	e5840054 	str	r0, [r4, #84]	; 0x54                          
    40cc:	e5d42047 	ldrb	r2, [r4, #71]	; 0x47                         
			              rtems_clock_get_ticks_per_second() / 10;             
			if (tty->termios.c_cc[VTIME]) {                                    
    40d0:	0a000006 	beq	40f0 <rtems_termios_ioctl+0x294>              
				tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                       
				tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;                  
				if (tty->termios.c_cc[VMIN])                                      
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
    40d4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    40d8:	01a02000 	moveq	r2, r0                                      <== NOT EXECUTED
    40dc:	13a02000 	movne	r2, #0                                      <== 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;                       
    40e0:	e584706c 	str	r7, [r4, #108]	; 0x6c                         <== NOT EXECUTED
				tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;                  
				if (tty->termios.c_cc[VMIN])                                      
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
    40e4:	e5842074 	str	r2, [r4, #116]	; 0x74                         <== 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;                  
    40e8:	e5840070 	str	r0, [r4, #112]	; 0x70                         <== NOT EXECUTED
    40ec:	ea000006 	b	410c <rtems_termios_ioctl+0x2b0>                <== NOT EXECUTED
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
				else                                                              
					tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;            
			}                                                                  
			else {                                                             
				if (tty->termios.c_cc[VMIN]) {                                    
    40f0:	e3520000 	cmp	r2, #0                                        
					tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                      
					tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
				}                                                                 
				else {                                                            
					tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;                   
    40f4:	03a03001 	moveq	r3, #1                                      
    40f8:	0584306c 	streq	r3, [r4, #108]	; 0x6c                       
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
				else                                                              
					tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;            
			}                                                                  
			else {                                                             
				if (tty->termios.c_cc[VMIN]) {                                    
    40fc:	0a000002 	beq	410c <rtems_termios_ioctl+0x2b0>              
					tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                      
					tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                
					tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;           
    4100:	e5843074 	str	r3, [r4, #116]	; 0x74                         
				else                                                              
					tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;            
			}                                                                  
			else {                                                             
				if (tty->termios.c_cc[VMIN]) {                                    
					tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                      
    4104:	e584306c 	str	r3, [r4, #108]	; 0x6c                         
					tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;                
    4108:	e5843070 	str	r3, [r4, #112]	; 0x70                         
				else {                                                            
					tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;                   
				}                                                                 
			}                                                                  
		}                                                                   
		if (tty->device.setAttributes)                                      
    410c:	e59430a8 	ldr	r3, [r4, #168]	; 0xa8                         
    4110:	e3530000 	cmp	r3, #0                                        
    4114:	0a000032 	beq	41e4 <rtems_termios_ioctl+0x388>              
			(*tty->device.setAttributes)(tty->minor, &tty->termios);           
    4118:	e5940010 	ldr	r0, [r4, #16]                                 
    411c:	e2841030 	add	r1, r4, #48	; 0x30                            
    4120:	e1a0e00f 	mov	lr, pc                                        
    4124:	e12fff13 	bx	r3                                             
    4128:	ea00002d 	b	41e4 <rtems_termios_ioctl+0x388>                
		break;                                                              
                                                                      
	case RTEMS_IO_TCDRAIN:                                               
		drainOutput (tty);                                                  
    412c:	e1a00004 	mov	r0, r4                                        
    4130:	ebfffe5a 	bl	3aa0 <drainOutput>                             
		break;                                                              
    4134:	ea00002a 	b	41e4 <rtems_termios_ioctl+0x388>                
                                                                      
	case RTEMS_IO_SNDWAKEUP:                                             
		tty->tty_snd = *wakeup;                                             
    4138:	e897000c 	ldm	r7, {r2, r3}                                  <== NOT EXECUTED
    413c:	e58420d4 	str	r2, [r4, #212]	; 0xd4                         <== NOT EXECUTED
    4140:	e58430d8 	str	r3, [r4, #216]	; 0xd8                         <== NOT EXECUTED
		break;                                                              
    4144:	ea000026 	b	41e4 <rtems_termios_ioctl+0x388>                <== NOT EXECUTED
                                                                      
	case RTEMS_IO_RCVWAKEUP:                                             
		tty->tty_rcv = *wakeup;                                             
    4148:	e897000c 	ldm	r7, {r2, r3}                                  <== NOT EXECUTED
    414c:	e58420dc 	str	r2, [r4, #220]	; 0xdc                         <== NOT EXECUTED
    4150:	e58430e0 	str	r3, [r4, #224]	; 0xe0                         <== NOT EXECUTED
		break;                                                              
    4154:	ea000022 	b	41e4 <rtems_termios_ioctl+0x388>                <== NOT EXECUTED
#if 1 /* FIXME */                                                     
	case TIOCSETD:                                                       
		/*                                                                  
		 * close old line discipline                                        
		 */                                                                 
		if (rtems_termios_linesw[tty->t_line].l_close != NULL) {            
    4158:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         <== NOT EXECUTED
    415c:	e59f309c 	ldr	r3, [pc, #156]	; 4200 <rtems_termios_ioctl+0x3a4><== NOT EXECUTED
    4160:	e0833282 	add	r3, r3, r2, lsl #5                            <== NOT EXECUTED
    4164:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
    4168:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    416c:	0a000003 	beq	4180 <rtems_termios_ioctl+0x324>              <== NOT EXECUTED
			sc = rtems_termios_linesw[tty->t_line].l_close(tty);               
    4170:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    4174:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    4178:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    417c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
		}                                                                   
		tty->t_line=*(int*)(args->buffer);                                  
    4180:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
    4184:	e5932000 	ldr	r2, [r3]                                      <== 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) {             
    4188:	e59f3070 	ldr	r3, [pc, #112]	; 4200 <rtems_termios_ioctl+0x3a4><== NOT EXECUTED
    418c:	e7933282 	ldr	r3, [r3, r2, lsl #5]                          <== NOT EXECUTED
		 */                                                                 
		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);                                  
		tty->t_sc = NULL; /* ensure that no more valid data */              
    4190:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
		/*                                                                  
		 * open new line discipline                                         
		 */                                                                 
		if (rtems_termios_linesw[tty->t_line].l_open != NULL) {             
    4194:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
		 */                                                                 
		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);                                  
		tty->t_sc = NULL; /* ensure that no more valid data */              
    4198:	e58410d0 	str	r1, [r4, #208]	; 0xd0                         <== 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);                                  
    419c:	e58420cc 	str	r2, [r4, #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) {             
    41a0:	0a00000f 	beq	41e4 <rtems_termios_ioctl+0x388>              <== NOT EXECUTED
			sc = rtems_termios_linesw[tty->t_line].l_open(tty);                
    41a4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    41a8:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    41ac:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    41b0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    41b4:	ea00000a 	b	41e4 <rtems_termios_ioctl+0x388>                <== NOT EXECUTED
		*(int*)(args->buffer)=tty->t_line;                                  
		break;                                                              
#endif                                                                
 	case FIONREAD:                                                      
		{                                                                   
		int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;                
    41b8:	e5942060 	ldr	r2, [r4, #96]	; 0x60                          <== NOT EXECUTED
    41bc:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
		if ( rawnc < 0 )                                                    
    41c0:	e0523003 	subs	r3, r2, r3                                   <== NOT EXECUTED
			rawnc += tty->rawInBuf.Size;                                       
    41c4:	45942064 	ldrmi	r2, [r4, #100]	; 0x64                       <== NOT EXECUTED
    41c8:	40833002 	addmi	r3, r3, r2                                  <== NOT EXECUTED
		/* Half guess that this is the right operation */                   
		*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;           
    41cc:	e2842020 	add	r2, r4, #32                                   <== NOT EXECUTED
    41d0:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
    41d4:	e0411002 	sub	r1, r1, r2                                    <== NOT EXECUTED
    41d8:	e5952008 	ldr	r2, [r5, #8]                                  <== NOT EXECUTED
    41dc:	e0813003 	add	r3, r1, r3                                    <== NOT EXECUTED
    41e0:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
		}                                                                   
		break;                                                              
	}                                                                    
	rtems_semaphore_release (tty->osem);                                 
    41e4:	e5940018 	ldr	r0, [r4, #24]                                 
    41e8:	eb000431 	bl	52b4 <rtems_semaphore_release>                 
	args->ioctl_return = sc;                                             
    41ec:	e585600c 	str	r6, [r5, #12]                                 
	return sc;                                                           
}                                                                     
    41f0:	e1a00006 	mov	r0, r6                                        
    41f4:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

0000439c <rtems_termios_open>: rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) {
    439c:	e92d4ff3 	push	{r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} 
    43a0:	e1a08002 	mov	r8, r2                                        
	struct rtems_termios_tty *tty;                                       
                                                                      
	/*                                                                   
	 * See if the device has already been opened                         
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
    43a4:	e59f23e0 	ldr	r2, [pc, #992]	; 478c <rtems_termios_open+0x3f0>
  rtems_device_major_number      major,                               
  rtems_device_minor_number      minor,                               
  void                          *arg,                                 
  const rtems_termios_callbacks *callbacks                            
  )                                                                   
{                                                                     
    43a8:	e1a0a001 	mov	sl, r1                                        
	struct rtems_termios_tty *tty;                                       
                                                                      
	/*                                                                   
	 * See if the device has already been opened                         
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
    43ac:	e3a01000 	mov	r1, #0                                        
  rtems_device_major_number      major,                               
  rtems_device_minor_number      minor,                               
  void                          *arg,                                 
  const rtems_termios_callbacks *callbacks                            
  )                                                                   
{                                                                     
    43b0:	e1a09000 	mov	r9, r0                                        
	struct rtems_termios_tty *tty;                                       
                                                                      
	/*                                                                   
	 * See if the device has already been opened                         
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
    43b4:	e5920000 	ldr	r0, [r2]                                      
    43b8:	e1a02001 	mov	r2, r1                                        
  rtems_device_major_number      major,                               
  rtems_device_minor_number      minor,                               
  void                          *arg,                                 
  const rtems_termios_callbacks *callbacks                            
  )                                                                   
{                                                                     
    43bc:	e1a0b003 	mov	fp, r3                                        
	struct rtems_termios_tty *tty;                                       
                                                                      
	/*                                                                   
	 * See if the device has already been opened                         
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
    43c0:	eb000375 	bl	519c <rtems_semaphore_obtain>                  
				     RTEMS_WAIT, RTEMS_NO_TIMEOUT);                               
	if (sc != RTEMS_SUCCESSFUL)                                          
    43c4:	e2506000 	subs	r6, r0, #0                                   
		return sc;                                                          
	for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {  
    43c8:	059f33c0 	ldreq	r3, [pc, #960]	; 4790 <rtems_termios_open+0x3f4>
    43cc:	05935000 	ldreq	r5, [r3]                                    
	/*                                                                   
	 * See if the device has already been opened                         
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
				     RTEMS_WAIT, RTEMS_NO_TIMEOUT);                               
	if (sc != RTEMS_SUCCESSFUL)                                          
    43d0:	0a000007 	beq	43f4 <rtems_termios_open+0x58>                
    43d4:	ea0000e2 	b	4764 <rtems_termios_open+0x3c8>                 <== NOT EXECUTED
		return sc;                                                          
	for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {  
		if ((tty->major == major) && (tty->minor == minor))                 
    43d8:	e595300c 	ldr	r3, [r5, #12]                                 
    43dc:	e1530009 	cmp	r3, r9                                        
    43e0:	1a000002 	bne	43f0 <rtems_termios_open+0x54>                
    43e4:	e5953010 	ldr	r3, [r5, #16]                                 
    43e8:	e153000a 	cmp	r3, sl                                        
    43ec:	0a0000bb 	beq	46e0 <rtems_termios_open+0x344>               
	 */                                                                  
	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,                 
				     RTEMS_WAIT, RTEMS_NO_TIMEOUT);                               
	if (sc != RTEMS_SUCCESSFUL)                                          
		return sc;                                                          
	for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {  
    43f0:	e5955000 	ldr	r5, [r5]                                      
    43f4:	e3550000 	cmp	r5, #0                                        
    43f8:	1afffff6 	bne	43d8 <rtems_termios_open+0x3c>                
    43fc:	ea0000da 	b	476c <rtems_termios_open+0x3d0>                 
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * allocate raw input buffer                                        
		 */                                                                 
		tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                         
    4400:	e59f738c 	ldr	r7, [pc, #908]	; 4794 <rtems_termios_open+0x3f8>
    4404:	e5973004 	ldr	r3, [r7, #4]                                  
    4408:	e5853064 	str	r3, [r5, #100]	; 0x64                         
		tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);                 
    440c:	e5950064 	ldr	r0, [r5, #100]	; 0x64                         
    4410:	ebfff77a 	bl	2200 <malloc>                                  
		if (tty->rawInBuf.theBuf == NULL) {                                 
    4414:	e3500000 	cmp	r0, #0                                        
		}                                                                   
		/*                                                                  
		 * allocate raw input buffer                                        
		 */                                                                 
		tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                         
		tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);                 
    4418:	e5850058 	str	r0, [r5, #88]	; 0x58                          
		if (tty->rawInBuf.theBuf == NULL) {                                 
    441c:	1a000006 	bne	443c <rtems_termios_open+0xa0>                
		        free(tty);                                                  
    4420:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    4424:	ebfff6a9 	bl	1ed0 <free>                                    <== NOT EXECUTED
			rtems_semaphore_release (rtems_termios_ttyMutex);                  
    4428:	e59f335c 	ldr	r3, [pc, #860]	; 478c <rtems_termios_open+0x3f0><== NOT EXECUTED
    442c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
    4430:	eb00039f 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
    4434:	e3a0601a 	mov	r6, #26                                       <== NOT EXECUTED
			return RTEMS_NO_MEMORY;                                            
    4438:	ea0000c9 	b	4764 <rtems_termios_open+0x3c8>                 <== NOT EXECUTED
		}                                                                   
		/*                                                                  
		 * allocate raw output buffer                                       
		 */                                                                 
		tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                       
    443c:	e5973008 	ldr	r3, [r7, #8]                                  
    4440:	e5853088 	str	r3, [r5, #136]	; 0x88                         
		tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);               
    4444:	e5950088 	ldr	r0, [r5, #136]	; 0x88                         
    4448:	ebfff76c 	bl	2200 <malloc>                                  
		if (tty->rawOutBuf.theBuf == NULL) {                                
    444c:	e3500000 	cmp	r0, #0                                        
		}                                                                   
		/*                                                                  
		 * allocate raw output buffer                                       
		 */                                                                 
		tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                       
		tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);               
    4450:	e585007c 	str	r0, [r5, #124]	; 0x7c                         
		if (tty->rawOutBuf.theBuf == NULL) {                                
    4454:	0a000006 	beq	4474 <rtems_termios_open+0xd8>                
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * allocate cooked buffer                                           
		 */                                                                 
		tty->cbuf  = malloc (CBUFSIZE);                                     
    4458:	e5970000 	ldr	r0, [r7]                                      
    445c:	ebfff767 	bl	2200 <malloc>                                  
		if (tty->cbuf == NULL) {                                            
    4460:	e3500000 	cmp	r0, #0                                        
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * allocate cooked buffer                                           
		 */                                                                 
		tty->cbuf  = malloc (CBUFSIZE);                                     
    4464:	e585001c 	str	r0, [r5, #28]                                 
		if (tty->cbuf == NULL) {                                            
    4468:	1a000004 	bne	4480 <rtems_termios_open+0xe4>                
		        free((void *)(tty->rawOutBuf.theBuf));                      
    446c:	e595007c 	ldr	r0, [r5, #124]	; 0x7c                         <== NOT EXECUTED
    4470:	ebfff696 	bl	1ed0 <free>                                    <== NOT EXECUTED
		        free((void *)(tty->rawInBuf.theBuf));                       
    4474:	e5950058 	ldr	r0, [r5, #88]	; 0x58                          <== NOT EXECUTED
    4478:	ebfff694 	bl	1ed0 <free>                                    <== NOT EXECUTED
    447c:	eaffffe7 	b	4420 <rtems_termios_open+0x84>                  <== NOT EXECUTED
		tty->tty_rcvwakeup  = 0;                                            
                                                                      
		/*                                                                  
		 * link tty                                                         
		 */                                                                 
		tty->forw = rtems_termios_ttyHead;                                  
    4480:	e59f3308 	ldr	r3, [pc, #776]	; 4790 <rtems_termios_open+0x3f4>
    4484:	e5932000 	ldr	r2, [r3]                                      
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * Initialize wakeup callbacks                                      
		 */                                                                 
		tty->tty_snd.sw_pfn = NULL;                                         
    4488:	e3a03000 	mov	r3, #0                                        
		/*                                                                  
		 * link tty                                                         
		 */                                                                 
		tty->forw = rtems_termios_ttyHead;                                  
		tty->back = NULL;                                                   
		if (rtems_termios_ttyHead != NULL)                                  
    448c:	e3520000 	cmp	r2, #0                                        
                                                                      
		/*                                                                  
		 * link tty                                                         
		 */                                                                 
		tty->forw = rtems_termios_ttyHead;                                  
		tty->back = NULL;                                                   
    4490:	e885000c 	stm	r5, {r2, r3}                                  
		if (rtems_termios_ttyHead != NULL)                                  
			rtems_termios_ttyHead->back = tty;                                 
    4494:	15825004 	strne	r5, [r2, #4]                                
			return RTEMS_NO_MEMORY;                                            
		}                                                                   
		/*                                                                  
		 * Initialize wakeup callbacks                                      
		 */                                                                 
		tty->tty_snd.sw_pfn = NULL;                                         
    4498:	e58530d4 	str	r3, [r5, #212]	; 0xd4                         
		tty->tty_snd.sw_arg = NULL;                                         
    449c:	e58530d8 	str	r3, [r5, #216]	; 0xd8                         
		tty->tty_rcv.sw_pfn = NULL;                                         
    44a0:	e58530dc 	str	r3, [r5, #220]	; 0xdc                         
		tty->tty_rcv.sw_arg = NULL;                                         
    44a4:	e58530e0 	str	r3, [r5, #224]	; 0xe0                         
		tty->tty_rcvwakeup  = 0;                                            
    44a8:	e58530e4 	str	r3, [r5, #228]	; 0xe4                         
		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)                                  
    44ac:	e59f32e4 	ldr	r3, [pc, #740]	; 4798 <rtems_termios_open+0x3fc>
    44b0:	e5932000 	ldr	r2, [r3]                                      
		tty->major = major;                                                 
                                                                      
		/*                                                                  
		 * Set up mutex semaphores                                          
		 */                                                                 
		sc = rtems_semaphore_create (                                       
    44b4:	e59f72d8 	ldr	r7, [pc, #728]	; 4794 <rtems_termios_open+0x3f8>
		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)                                  
    44b8:	e3520000 	cmp	r2, #0                                        
			rtems_termios_ttyTail = tty;                                       
    44bc:	05834000 	streq	r4, [r3]                                    
		 */                                                                 
		tty->forw = rtems_termios_ttyHead;                                  
		tty->back = NULL;                                                   
		if (rtems_termios_ttyHead != NULL)                                  
			rtems_termios_ttyHead->back = tty;                                 
		rtems_termios_ttyHead = tty;                                        
    44c0:	e59f22c8 	ldr	r2, [pc, #712]	; 4790 <rtems_termios_open+0x3f4>
		tty->major = major;                                                 
                                                                      
		/*                                                                  
		 * Set up mutex semaphores                                          
		 */                                                                 
		sc = rtems_semaphore_create (                                       
    44c4:	e5d7300c 	ldrb	r3, [r7, #12]                                
    44c8:	e59f02cc 	ldr	r0, [pc, #716]	; 479c <rtems_termios_open+0x400>
		 */                                                                 
		tty->forw = rtems_termios_ttyHead;                                  
		tty->back = NULL;                                                   
		if (rtems_termios_ttyHead != NULL)                                  
			rtems_termios_ttyHead->back = tty;                                 
		rtems_termios_ttyHead = tty;                                        
    44cc:	e5824000 	str	r4, [r2]                                      
		tty->major = major;                                                 
                                                                      
		/*                                                                  
		 * Set up mutex semaphores                                          
		 */                                                                 
		sc = rtems_semaphore_create (                                       
    44d0:	e1830000 	orr	r0, r3, r0                                    
			rtems_termios_ttyHead->back = tty;                                 
		rtems_termios_ttyHead = tty;                                        
		if (rtems_termios_ttyTail == NULL)                                  
			rtems_termios_ttyTail = tty;                                       
                                                                      
		tty->minor = minor;                                                 
    44d4:	e584a010 	str	sl, [r4, #16]                                 
		tty->major = major;                                                 
    44d8:	e584900c 	str	r9, [r4, #12]                                 
                                                                      
		/*                                                                  
		 * Set up mutex semaphores                                          
		 */                                                                 
		sc = rtems_semaphore_create (                                       
    44dc:	e284c014 	add	ip, r4, #20                                   
    44e0:	e3a03000 	mov	r3, #0                                        
    44e4:	e3a01001 	mov	r1, #1                                        
    44e8:	e3a02054 	mov	r2, #84	; 0x54                                
    44ec:	e58dc000 	str	ip, [sp]                                      
    44f0:	eb000297 	bl	4f54 <rtems_semaphore_create>                  
			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)                                         
    44f4:	e2503000 	subs	r3, r0, #0                                   
    44f8:	1a000095 	bne	4754 <rtems_termios_open+0x3b8>               
			rtems_fatal_error_occurred (sc);                                   
		sc = rtems_semaphore_create (                                       
    44fc:	e5d7200c 	ldrb	r2, [r7, #12]                                
    4500:	e59f0298 	ldr	r0, [pc, #664]	; 47a0 <rtems_termios_open+0x404>
    4504:	e284c018 	add	ip, r4, #24                                   
    4508:	e1820000 	orr	r0, r2, r0                                    
    450c:	e3a01001 	mov	r1, #1                                        
    4510:	e3a02054 	mov	r2, #84	; 0x54                                
    4514:	e58dc000 	str	ip, [sp]                                      
    4518:	eb00028d 	bl	4f54 <rtems_semaphore_create>                  
			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)                                         
    451c:	e2501000 	subs	r1, r0, #0                                   
    4520:	1a00008b 	bne	4754 <rtems_termios_open+0x3b8>               
			rtems_fatal_error_occurred (sc);                                   
		sc = rtems_semaphore_create (                                       
    4524:	e5d7300c 	ldrb	r3, [r7, #12]                                
    4528:	e59f0274 	ldr	r0, [pc, #628]	; 47a4 <rtems_termios_open+0x408>
    452c:	e284c08c 	add	ip, r4, #140	; 0x8c                           
    4530:	e1830000 	orr	r0, r3, r0                                    
    4534:	e3a02020 	mov	r2, #32                                       
    4538:	e1a03001 	mov	r3, r1                                        
    453c:	e58dc000 	str	ip, [sp]                                      
    4540:	eb000283 	bl	4f54 <rtems_semaphore_create>                  
			rtems_build_name ('T', 'R', 'x', c),                               
			0,                                                                 
			RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,                        
			RTEMS_NO_PRIORITY,                                                 
			&tty->rawOutBuf.Semaphore);                                        
		if (sc != RTEMS_SUCCESSFUL)                                         
    4544:	e250e000 	subs	lr, r0, #0                                   
    4548:	1a000081 	bne	4754 <rtems_termios_open+0x3b8>               
		tty->rawOutBufState = rob_idle;                                     
                                                                      
		/*                                                                  
		 * Set callbacks                                                    
		 */                                                                 
		tty->device = *callbacks;                                           
    454c:	e8bb000f 	ldm	fp!, {r0, r1, r2, r3}                         
    4550:	e284c098 	add	ip, r4, #152	; 0x98                           
    4554:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    4558:	e89b000f 	ldm	fp, {r0, r1, r2, r3}                          
    455c:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          
                                                                      
		/*                                                                  
		 * Create I/O tasks                                                 
		 */                                                                 
		if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
    4560:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         
    4564:	e3530002 	cmp	r3, #2                                        
			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;                                     
    4568:	e584e094 	str	lr, [r4, #148]	; 0x94                         
		tty->device = *callbacks;                                           
                                                                      
		/*                                                                  
		 * Create I/O tasks                                                 
		 */                                                                 
		if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
    456c:	1a000017 	bne	45d0 <rtems_termios_open+0x234>               
			sc = rtems_task_create (                                           
    4570:	e5d7300c 	ldrb	r3, [r7, #12]                                <== NOT EXECUTED
    4574:	e59f022c 	ldr	r0, [pc, #556]	; 47a8 <rtems_termios_open+0x40c><== NOT EXECUTED
    4578:	e284c0c8 	add	ip, r4, #200	; 0xc8                           <== NOT EXECUTED
    457c:	e1830000 	orr	r0, r3, r0                                    <== NOT EXECUTED
    4580:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
    4584:	e3a02b01 	mov	r2, #1024	; 0x400                             <== NOT EXECUTED
    4588:	e3a03c05 	mov	r3, #1280	; 0x500                             <== NOT EXECUTED
    458c:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
    4590:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
    4594:	eb00036d 	bl	5350 <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)                                        
    4598:	e250e000 	subs	lr, r0, #0                                   <== NOT EXECUTED
    459c:	1a00006c 	bne	4754 <rtems_termios_open+0x3b8>               <== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
			sc = rtems_task_create (                                           
    45a0:	e5d7300c 	ldrb	r3, [r7, #12]                                <== NOT EXECUTED
    45a4:	e59f0200 	ldr	r0, [pc, #512]	; 47ac <rtems_termios_open+0x410><== NOT EXECUTED
    45a8:	e284c0c4 	add	ip, r4, #196	; 0xc4                           <== NOT EXECUTED
    45ac:	e1830000 	orr	r0, r3, r0                                    <== NOT EXECUTED
    45b0:	e3a01009 	mov	r1, #9                                        <== NOT EXECUTED
    45b4:	e3a02b01 	mov	r2, #1024	; 0x400                             <== NOT EXECUTED
    45b8:	e3a03c05 	mov	r3, #1280	; 0x500                             <== NOT EXECUTED
    45bc:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
    45c0:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
    45c4:	eb000361 	bl	5350 <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)                                        
    45c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    45cc:	1a000060 	bne	4754 <rtems_termios_open+0x3b8>               <== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
                                                                      
		}                                                                   
		if ((tty->device.pollRead == NULL) ||                               
    45d0:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         
    45d4:	e3530000 	cmp	r3, #0                                        
    45d8:	0a000002 	beq	45e8 <rtems_termios_open+0x24c>               
		    (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){     
    45dc:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         
    45e0:	e3530002 	cmp	r3, #2                                        
    45e4:	1a00000b 	bne	4618 <rtems_termios_open+0x27c>               
			sc = rtems_semaphore_create (                                      
    45e8:	e59f31a4 	ldr	r3, [pc, #420]	; 4794 <rtems_termios_open+0x3f8><== NOT EXECUTED
    45ec:	e59f01bc 	ldr	r0, [pc, #444]	; 47b0 <rtems_termios_open+0x414><== NOT EXECUTED
    45f0:	e5d3300c 	ldrb	r3, [r3, #12]                                <== NOT EXECUTED
    45f4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    45f8:	e1830000 	orr	r0, r3, r0                                    <== NOT EXECUTED
    45fc:	e284c068 	add	ip, r4, #104	; 0x68                           <== NOT EXECUTED
    4600:	e3a02024 	mov	r2, #36	; 0x24                                <== NOT EXECUTED
    4604:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
    4608:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
    460c:	eb000250 	bl	4f54 <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)                                        
    4610:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    4614:	1a00004e 	bne	4754 <rtems_termios_open+0x3b8>               <== 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';                                   
    4618:	e3a03000 	mov	r3, #0                                        
		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;                                                 
    461c:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         
		/*                                                                  
		 * set low/highwater mark for XON/XOFF support                      
		 */                                                                 
		tty->lowwater  = tty->rawInBuf.Size * 1/2;                          
    4620:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         
		tty->highwater = tty->rawInBuf.Size * 3/4;                          
    4624:	e594c064 	ldr	ip, [r4, #100]	; 0x64                         
		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 = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
                                                                      
		tty->termios.c_cc[VINTR] = '\003';                                  
    4628:	e3a02003 	mov	r2, #3                                        
		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;                          
    462c:	e0000c92 	mul	r0, r2, ip                                    
		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';                                  
		tty->termios.c_cc[VQUIT] = '\034';                                  
    4630:	e3a0c01c 	mov	ip, #28                                       
    4634:	e5c4c042 	strb	ip, [r4, #66]	; 0x42                         
		tty->termios.c_cc[VERASE] = '\177';                                 
    4638:	e28cc063 	add	ip, ip, #99	; 0x63                            
    463c:	e5c4c043 	strb	ip, [r4, #67]	; 0x43                         
		tty->termios.c_cc[VKILL] = '\025';                                  
    4640:	e3a0c015 	mov	ip, #21                                       
    4644:	e5c4c044 	strb	ip, [r4, #68]	; 0x44                         
		tty->termios.c_cc[VEOF] = '\004';                                   
    4648:	e3a0c004 	mov	ip, #4                                        
    464c:	e5c4c045 	strb	ip, [r4, #69]	; 0x45                         
		tty->termios.c_cc[VEOL] = '\000';                                   
		tty->termios.c_cc[VEOL2] = '\000';                                  
		tty->termios.c_cc[VSTART] = '\021';                                 
    4650:	e28cc00d 	add	ip, ip, #13                                   
    4654:	e5c4c049 	strb	ip, [r4, #73]	; 0x49                         
		tty->termios.c_cc[VSTOP] = '\023';                                  
    4658:	e28cc002 	add	ip, ip, #2                                    
    465c:	e5c4c04a 	strb	ip, [r4, #74]	; 0x4a                         
		tty->termios.c_cc[VSUSP] = '\032';                                  
    4660:	e28cc007 	add	ip, ip, #7                                    
    4664:	e5c4c04b 	strb	ip, [r4, #75]	; 0x4b                         
		tty->termios.c_cc[VREPRINT] = '\022';                               
    4668:	e3a0c012 	mov	ip, #18                                       
    466c:	e5c4c04d 	strb	ip, [r4, #77]	; 0x4d                         
		tty->termios.c_cc[VDISCARD] = '\017';                               
    4670:	e3a0c00f 	mov	ip, #15                                       
    4674:	e5c4c04e 	strb	ip, [r4, #78]	; 0x4e                         
		tty->termios.c_cc[VWERASE] = '\027';                                
    4678:	e28cc008 	add	ip, ip, #8                                    
    467c:	e5c4c04f 	strb	ip, [r4, #79]	; 0x4f                         
		tty->termios.c_cc[VLNEXT] = '\026';                                 
    4680:	e3a0c016 	mov	ip, #22                                       
		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';                                   
    4684:	e5c4304c 	strb	r3, [r4, #76]	; 0x4c                         
		tty->termios.c_cc[VEOL2] = '\000';                                  
    4688:	e5c43051 	strb	r3, [r4, #81]	; 0x51                         
		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';                                 
    468c:	e5c4c050 	strb	ip, [r4, #80]	; 0x50                         
		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 = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
                                                                      
		tty->termios.c_cc[VINTR] = '\003';                                  
    4690:	e5c42041 	strb	r2, [r4, #65]	; 0x41                         
		tty->lowwater  = tty->rawInBuf.Size * 1/2;                          
		tty->highwater = tty->rawInBuf.Size * 3/4;                          
		/*                                                                  
		 * Bump name characer                                               
		 */                                                                 
		if (c++ == 'z')                                                     
    4694:	e59f30f8 	ldr	r3, [pc, #248]	; 4794 <rtems_termios_open+0x3f8>
		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;                          
    4698:	e1a00120 	lsr	r0, r0, #2                                    
		/*                                                                  
		 * Bump name characer                                               
		 */                                                                 
		if (c++ == 'z')                                                     
    469c:	e5d3200c 	ldrb	r2, [r3, #12]                                
		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;                          
    46a0:	e58400c0 	str	r0, [r4, #192]	; 0xc0                         
		}                                                                   
                                                                      
		/*                                                                  
		 * Set default parameters                                           
		 */                                                                 
		tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;             
    46a4:	e59f0108 	ldr	r0, [pc, #264]	; 47b4 <rtems_termios_open+0x418>
    46a8:	e5840030 	str	r0, [r4, #48]	; 0x30                          
		tty->termios.c_oflag = OPOST | ONLCR | XTABS;                       
    46ac:	e59f0104 	ldr	r0, [pc, #260]	; 47b8 <rtems_termios_open+0x41c>
    46b0:	e5840034 	str	r0, [r4, #52]	; 0x34                          
		tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;                
    46b4:	e59f0100 	ldr	r0, [pc, #256]	; 47bc <rtems_termios_open+0x420>
    46b8:	e5840038 	str	r0, [r4, #56]	; 0x38                          
		tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
    46bc:	e59f00fc 	ldr	r0, [pc, #252]	; 47c0 <rtems_termios_open+0x424>
		tty->lowwater  = tty->rawInBuf.Size * 1/2;                          
		tty->highwater = tty->rawInBuf.Size * 3/4;                          
		/*                                                                  
		 * Bump name characer                                               
		 */                                                                 
		if (c++ == 'z')                                                     
    46c0:	e352007a 	cmp	r2, #122	; 0x7a                               
		/* 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;                          
    46c4:	e1a010a1 	lsr	r1, r1, #1                                    
		tty->highwater = tty->rawInBuf.Size * 3/4;                          
		/*                                                                  
		 * Bump name characer                                               
		 */                                                                 
		if (c++ == 'z')                                                     
    46c8:	e2822001 	add	r2, r2, #1                                    
		 * 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 = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
    46cc:	e584003c 	str	r0, [r4, #60]	; 0x3c                          
		/* 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;                          
    46d0:	e58410bc 	str	r1, [r4, #188]	; 0xbc                         
		tty->highwater = tty->rawInBuf.Size * 3/4;                          
		/*                                                                  
		 * Bump name characer                                               
		 */                                                                 
		if (c++ == 'z')                                                     
    46d4:	e5c3200c 	strb	r2, [r3, #12]                                
			c = 'a';                                                           
    46d8:	03a02061 	moveq	r2, #97	; 0x61                              
    46dc:	05c3200c 	strbeq	r2, [r3, #12]                              
                                                                      
	}                                                                    
	args->iop->data1 = tty;                                              
	if (!tty->refcount++) {                                              
    46e0:	e5953008 	ldr	r3, [r5, #8]                                  
		 */                                                                 
		if (c++ == 'z')                                                     
			c = 'a';                                                           
                                                                      
	}                                                                    
	args->iop->data1 = tty;                                              
    46e4:	e5982000 	ldr	r2, [r8]                                      
	if (!tty->refcount++) {                                              
    46e8:	e3530000 	cmp	r3, #0                                        
    46ec:	e2833001 	add	r3, r3, #1                                    
		 */                                                                 
		if (c++ == 'z')                                                     
			c = 'a';                                                           
                                                                      
	}                                                                    
	args->iop->data1 = tty;                                              
    46f0:	e5825034 	str	r5, [r2, #52]	; 0x34                          
	if (!tty->refcount++) {                                              
    46f4:	e5853008 	str	r3, [r5, #8]                                  
    46f8:	1a000016 	bne	4758 <rtems_termios_open+0x3bc>               
	  if (tty->device.firstOpen)                                         
    46fc:	e5953098 	ldr	r3, [r5, #152]	; 0x98                         
    4700:	e3530000 	cmp	r3, #0                                        
		(*tty->device.firstOpen)(major, minor, arg);                        
    4704:	11a00009 	movne	r0, r9                                      
    4708:	11a0100a 	movne	r1, sl                                      
    470c:	11a02008 	movne	r2, r8                                      
    4710:	11a0e00f 	movne	lr, pc                                      
    4714:	112fff13 	bxne	r3                                           
	  /*                                                                 
	   * start I/O tasks, if needed                                      
	   */                                                                
	  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {     
    4718:	e59530b4 	ldr	r3, [r5, #180]	; 0xb4                         
    471c:	e3530002 	cmp	r3, #2                                        
    4720:	1a00000c 	bne	4758 <rtems_termios_open+0x3bc>               
	    sc = rtems_task_start(tty->rxTaskId,                             
    4724:	e59500c4 	ldr	r0, [r5, #196]	; 0xc4                         <== NOT EXECUTED
    4728:	e59f1094 	ldr	r1, [pc, #148]	; 47c4 <rtems_termios_open+0x428><== NOT EXECUTED
    472c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    4730:	eb0003ab 	bl	55e4 <rtems_task_start>                        <== NOT EXECUTED
				  rtems_termios_rxdaemon,                                         
				  (rtems_task_argument)tty);                                      
	    if (sc != RTEMS_SUCCESSFUL)                                      
    4734:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    4738:	1a000005 	bne	4754 <rtems_termios_open+0x3b8>               <== NOT EXECUTED
	      rtems_fatal_error_occurred (sc);                               
                                                                      
	    sc = rtems_task_start(tty->txTaskId,                             
    473c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    4740:	e59500c8 	ldr	r0, [r5, #200]	; 0xc8                         <== NOT EXECUTED
    4744:	e59f107c 	ldr	r1, [pc, #124]	; 47c8 <rtems_termios_open+0x42c><== NOT EXECUTED
    4748:	eb0003a5 	bl	55e4 <rtems_task_start>                        <== NOT EXECUTED
				  rtems_termios_txdaemon,                                         
				  (rtems_task_argument)tty);                                      
	    if (sc != RTEMS_SUCCESSFUL)                                      
    474c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    4750:	0a000000 	beq	4758 <rtems_termios_open+0x3bc>               <== NOT EXECUTED
	      rtems_fatal_error_occurred (sc);                               
    4754:	eb000413 	bl	57a8 <rtems_fatal_error_occurred>              <== NOT EXECUTED
	  }                                                                  
	}                                                                    
	rtems_semaphore_release (rtems_termios_ttyMutex);                    
    4758:	e59f302c 	ldr	r3, [pc, #44]	; 478c <rtems_termios_open+0x3f0>
    475c:	e5930000 	ldr	r0, [r3]                                      
    4760:	eb0002d3 	bl	52b4 <rtems_semaphore_release>                 
	return RTEMS_SUCCESSFUL;                                             
}                                                                     
    4764:	e1a00006 	mov	r0, r6                                        
    4768:	e8bd8ffc 	pop	{r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}  
		static char c = 'a';                                                
                                                                      
		/*                                                                  
		 * Create a new device                                              
		 */                                                                 
		tty = calloc (1, sizeof (struct rtems_termios_tty));                
    476c:	e3a00001 	mov	r0, #1                                        
    4770:	e3a010e8 	mov	r1, #232	; 0xe8                               
    4774:	ebfff54d 	bl	1cb0 <calloc>                                  
		if (tty == NULL) {                                                  
    4778:	e3500000 	cmp	r0, #0                                        
		static char c = 'a';                                                
                                                                      
		/*                                                                  
		 * Create a new device                                              
		 */                                                                 
		tty = calloc (1, sizeof (struct rtems_termios_tty));                
    477c:	e1a05000 	mov	r5, r0                                        
    4780:	e1a04000 	mov	r4, r0                                        
		if (tty == NULL) {                                                  
    4784:	1affff1d 	bne	4400 <rtems_termios_open+0x64>                
    4788:	eaffff26 	b	4428 <rtems_termios_open+0x8c>                  <== NOT EXECUTED
                                                                      

00003344 <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) {
    3344:	e59230b4 	ldr	r3, [r2, #180]	; 0xb4                         
    3348:	e3530000 	cmp	r3, #0                                        
 * Send characters to device-specific code                            
 */                                                                   
void                                                                  
rtems_termios_puts (                                                  
  const void *_buf, int len, struct rtems_termios_tty *tty)           
{                                                                     
    334c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
    3350:	e1a04002 	mov	r4, r2                                        
    3354:	e1a0a000 	mov	sl, r0                                        
    3358:	e1a06001 	mov	r6, r1                                        
	const unsigned char *buf = _buf;                                     
	unsigned int newHead;                                                
	rtems_interrupt_level level;                                         
	rtems_status_code sc;                                                
                                                                      
	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {            
    335c:	1a000005 	bne	3378 <rtems_termios_puts+0x34>                
		(*tty->device.write)(tty->minor, (void *)buf, len);                 
    3360:	e1a01000 	mov	r1, r0                                        
    3364:	e1a02006 	mov	r2, r6                                        
    3368:	e5940010 	ldr	r0, [r4, #16]                                 
    336c:	e1a0e00f 	mov	lr, pc                                        
    3370:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         
		return;                                                             
    3374:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
	}                                                                    
	newHead = tty->rawOutBuf.Head;                                       
    3378:	e5925080 	ldr	r5, [r2, #128]	; 0x80                         <== NOT EXECUTED
    337c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
		 * with interrupts enabled.                                         
		 */                                                                 
		newHead = (newHead + 1) % tty->rawOutBuf.Size;                      
		rtems_interrupt_disable (level);                                    
		while (newHead == tty->rawOutBuf.Tail) {                            
			tty->rawOutBufState = rob_wait;                                    
    3380:	e3a09002 	mov	r9, #2                                        <== NOT EXECUTED
		  }                                                                 
		  else {                                                            
		    /* remember that output has been stopped due to flow ctrl*/     
		    tty->flow_ctrl |= FL_OSTOP;                                     
		  }                                                                 
		  tty->rawOutBufState = rob_busy;                                   
    3384:	e3a0b001 	mov	fp, #1                                        <== NOT EXECUTED
	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {            
		(*tty->device.write)(tty->minor, (void *)buf, len);                 
		return;                                                             
	}                                                                    
	newHead = tty->rawOutBuf.Head;                                       
	while (len) {                                                        
    3388:	ea00002b 	b	343c <rtems_termios_puts+0xf8>                  <== NOT EXECUTED
		 *	len -= ncopy                                                     
		 *                                                                  
		 * To minimize latency, the memcpy should be done                   
		 * with interrupts enabled.                                         
		 */                                                                 
		newHead = (newHead + 1) % tty->rawOutBuf.Size;                      
    338c:	e2850001 	add	r0, r5, #1                                    <== NOT EXECUTED
    3390:	e5941088 	ldr	r1, [r4, #136]	; 0x88                         <== NOT EXECUTED
    3394:	eb004e28 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    3398:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    339c:	ea000007 	b	33c0 <rtems_termios_puts+0x7c>                  <== NOT EXECUTED
		rtems_interrupt_disable (level);                                    
		while (newHead == tty->rawOutBuf.Tail) {                            
			tty->rawOutBufState = rob_wait;                                    
    33a0:	e5849094 	str	r9, [r4, #148]	; 0x94                         <== NOT EXECUTED
    33a4:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
			rtems_interrupt_enable (level);                                    
			sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,             
    33a8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    33ac:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         <== NOT EXECUTED
    33b0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    33b4:	eb000778 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
							RTEMS_WAIT,                                                    
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
    33b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
				rtems_fatal_error_occurred (sc);                                  
    33bc:	1b0008f9 	blne	57a8 <rtems_fatal_error_occurred>            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    33c0:	e10f8000 	mrs	r8, CPSR                                      <== NOT EXECUTED
    33c4:	e3883080 	orr	r3, r8, #128	; 0x80                           <== NOT EXECUTED
    33c8:	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) {                            
    33cc:	e5943084 	ldr	r3, [r4, #132]	; 0x84                         <== NOT EXECUTED
    33d0:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
    33d4:	0afffff1 	beq	33a0 <rtems_termios_puts+0x5c>                <== NOT EXECUTED
							RTEMS_NO_TIMEOUT);                                             
			if (sc != RTEMS_SUCCESSFUL)                                        
				rtems_fatal_error_occurred (sc);                                  
			rtems_interrupt_disable (level);                                   
		}                                                                   
		tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;                
    33d8:	e5943080 	ldr	r3, [r4, #128]	; 0x80                         <== NOT EXECUTED
    33dc:	e7da1007 	ldrb	r1, [sl, r7]                                 <== NOT EXECUTED
    33e0:	e594207c 	ldr	r2, [r4, #124]	; 0x7c                         <== NOT EXECUTED
    33e4:	e7c21003 	strb	r1, [r2, r3]                                 <== NOT EXECUTED
		tty->rawOutBuf.Head = newHead;                                      
		if (tty->rawOutBufState == rob_idle) {                              
    33e8:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
    33ec:	e3530000 	cmp	r3, #0                                        <== 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;                                      
    33f0:	e5845080 	str	r5, [r4, #128]	; 0x80                         <== NOT EXECUTED
		if (tty->rawOutBufState == rob_idle) {                              
    33f4:	1a00000d 	bne	3430 <rtems_termios_puts+0xec>                <== NOT EXECUTED
		  /* check, whether XOFF has been received */                       
		  if (!(tty->flow_ctrl & FL_ORCVXOF)) {                             
    33f8:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    33fc:	e3130010 	tst	r3, #16                                       <== 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;                                     
    3400:	159430b8 	ldrne	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
    3404:	13833020 	orrne	r3, r3, #32                                 <== NOT EXECUTED
    3408:	158430b8 	strne	r3, [r4, #184]	; 0xb8                       <== 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)) {                             
    340c:	1a000006 	bne	342c <rtems_termios_puts+0xe8>                <== NOT EXECUTED
		    (*tty->device.write)(tty->minor,                                
			(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);            
    3410:	e5943084 	ldr	r3, [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,                                
    3414:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
    3418:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    341c:	e0811003 	add	r1, r1, r3                                    <== NOT EXECUTED
    3420:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    3424:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3428:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
		  }                                                                 
		  else {                                                            
		    /* remember that output has been stopped due to flow ctrl*/     
		    tty->flow_ctrl |= FL_OSTOP;                                     
		  }                                                                 
		  tty->rawOutBufState = rob_busy;                                   
    342c:	e584b094 	str	fp, [r4, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    3430:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
		}                                                                   
		rtems_interrupt_enable (level);                                     
		len--;                                                              
    3434:	e2466001 	sub	r6, r6, #1                                    <== NOT EXECUTED
    3438:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {            
		(*tty->device.write)(tty->minor, (void *)buf, len);                 
		return;                                                             
	}                                                                    
	newHead = tty->rawOutBuf.Head;                                       
	while (len) {                                                        
    343c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    3440:	1affffd1 	bne	338c <rtems_termios_puts+0x48>                <== NOT EXECUTED
    3444:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

00003b0c <rtems_termios_read>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) {
    3b0c:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
    3b10:	e5903000 	ldr	r3, [r0]                                      
	return RTEMS_SUCCESSFUL;                                             
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
    3b14:	e1a05000 	mov	r5, r0                                        
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
    3b18:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          
	uint32_t   count = args->count;                                      
	char      *buffer = args->buffer;                                    
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    3b1c:	e3a01000 	mov	r1, #0                                        
rtems_termios_read (void *arg)                                        
{                                                                     
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
	uint32_t   count = args->count;                                      
	char      *buffer = args->buffer;                                    
    3b20:	e595300c 	ldr	r3, [r5, #12]                                 
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    3b24:	e5940014 	ldr	r0, [r4, #20]                                 
    3b28:	e1a02001 	mov	r2, r1                                        
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
	uint32_t   count = args->count;                                      
    3b2c:	e5957010 	ldr	r7, [r5, #16]                                 
	char      *buffer = args->buffer;                                    
    3b30:	e58d3000 	str	r3, [sp]                                      
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    3b34:	eb000598 	bl	519c <rtems_semaphore_obtain>                  
	if (sc != RTEMS_SUCCESSFUL)                                          
    3b38:	e2506000 	subs	r6, r0, #0                                   
    3b3c:	1a0000c1 	bne	3e48 <rtems_termios_read+0x33c>               
		return sc;                                                          
	if (rtems_termios_linesw[tty->t_line].l_read != NULL) {              
    3b40:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         
    3b44:	e59f3304 	ldr	r3, [pc, #772]	; 3e50 <rtems_termios_read+0x344>
    3b48:	e0833282 	add	r3, r3, r2, lsl #5                            
    3b4c:	e5933008 	ldr	r3, [r3, #8]                                  
    3b50:	e3530000 	cmp	r3, #0                                        
    3b54:	0a000005 	beq	3b70 <rtems_termios_read+0x64>                
		sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);            
    3b58:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
    3b5c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    3b60:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3b64:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    3b68:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    3b6c:	ea0000b1 	b	3e38 <rtems_termios_read+0x32c>                 <== NOT EXECUTED
		tty->tty_rcvwakeup = 0;                                             
		rtems_semaphore_release (tty->isem);                                
		return sc;                                                          
	}                                                                    
	if (tty->cindex == tty->ccount) {                                    
    3b70:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          
    3b74:	e5943020 	ldr	r3, [r4, #32]                                 
    3b78:	e1520003 	cmp	r2, r3                                        
    3b7c:	1a00009a 	bne	3dec <rtems_termios_read+0x2e0>               
		tty->cindex = tty->ccount = 0;                                      
		tty->read_start_column = tty->column;                               
		if (tty->device.pollRead != NULL                                    
    3b80:	e59420a0 	ldr	r2, [r4, #160]	; 0xa0                         
		rtems_semaphore_release (tty->isem);                                
		return sc;                                                          
	}                                                                    
	if (tty->cindex == tty->ccount) {                                    
		tty->cindex = tty->ccount = 0;                                      
		tty->read_start_column = tty->column;                               
    3b84:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
		if (tty->device.pollRead != NULL                                    
    3b88:	e3520000 	cmp	r2, #0                                        
		rtems_semaphore_release (tty->isem);                                
		return sc;                                                          
	}                                                                    
	if (tty->cindex == tty->ccount) {                                    
		tty->cindex = tty->ccount = 0;                                      
		tty->read_start_column = tty->column;                               
    3b8c:	e584302c 	str	r3, [r4, #44]	; 0x2c                          
		tty->tty_rcvwakeup = 0;                                             
		rtems_semaphore_release (tty->isem);                                
		return sc;                                                          
	}                                                                    
	if (tty->cindex == tty->ccount) {                                    
		tty->cindex = tty->ccount = 0;                                      
    3b90:	e5846020 	str	r6, [r4, #32]                                 
    3b94:	e5846024 	str	r6, [r4, #36]	; 0x24                          
		tty->read_start_column = tty->column;                               
		if (tty->device.pollRead != NULL                                    
    3b98:	0a00003b 	beq	3c8c <rtems_termios_read+0x180>               
		    && tty->device.outputUsesInterrupts == TERMIOS_POLLED)          
    3b9c:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         
    3ba0:	e3530000 	cmp	r3, #0                                        
    3ba4:	1a000038 	bne	3c8c <rtems_termios_read+0x180>               
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
	int n;                                                               
                                                                      
	if (tty->termios.c_lflag & ICANON) {                                 
    3ba8:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
    3bac:	e3130002 	tst	r3, #2                                        
    3bb0:	0a00000d 	beq	3bec <rtems_termios_read+0xe0>                
		for (;;) {                                                          
			n = (*tty->device.pollRead)(tty->minor);                           
    3bb4:	e5940010 	ldr	r0, [r4, #16]                                 
    3bb8:	e1a0e00f 	mov	lr, pc                                        
    3bbc:	e594f0a0 	ldr	pc, [r4, #160]	; 0xa0                         
			if (n < 0) {                                                       
    3bc0:	e3500000 	cmp	r0, #0                                        
				rtems_task_wake_after (1);                                        
			}                                                                  
			else {                                                             
				if  (siproc (n, tty))                                             
    3bc4:	e1a01004 	mov	r1, r4                                        
    3bc8:	e20000ff 	and	r0, r0, #255	; 0xff                           
	int n;                                                               
                                                                      
	if (tty->termios.c_lflag & ICANON) {                                 
		for (;;) {                                                          
			n = (*tty->device.pollRead)(tty->minor);                           
			if (n < 0) {                                                       
    3bcc:	aa000002 	bge	3bdc <rtems_termios_read+0xd0>                
				rtems_task_wake_after (1);                                        
    3bd0:	e3a00001 	mov	r0, #1                                        
    3bd4:	eb00069a 	bl	5644 <rtems_task_wake_after>                   
    3bd8:	eafffff5 	b	3bb4 <rtems_termios_read+0xa8>                  
			}                                                                  
			else {                                                             
				if  (siproc (n, tty))                                             
    3bdc:	ebffff67 	bl	3980 <siproc>                                  <== NOT EXECUTED
    3be0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    3be4:	0afffff2 	beq	3bb4 <rtems_termios_read+0xa8>                <== NOT EXECUTED
    3be8:	ea00007f 	b	3dec <rtems_termios_read+0x2e0>                 <== NOT EXECUTED
			}                                                                  
		}                                                                   
	}                                                                    
	else {                                                               
		rtems_interval then, now;                                           
		then = rtems_clock_get_ticks_since_boot();                          
    3bec:	eb0003de 	bl	4b6c <rtems_clock_get_ticks_since_boot>        
    3bf0:	e1a08000 	mov	r8, r0                                        
		for (;;) {                                                          
			n = (*tty->device.pollRead)(tty->minor);                           
    3bf4:	e5940010 	ldr	r0, [r4, #16]                                 
    3bf8:	e1a0e00f 	mov	lr, pc                                        
    3bfc:	e594f0a0 	ldr	pc, [r4, #160]	; 0xa0                         
			if (n < 0) {                                                       
    3c00:	e3500000 	cmp	r0, #0                                        
    3c04:	aa000013 	bge	3c58 <rtems_termios_read+0x14c>               
				if (tty->termios.c_cc[VMIN]) {                                    
    3c08:	e5d43047 	ldrb	r3, [r4, #71]	; 0x47                         
    3c0c:	e3530000 	cmp	r3, #0                                        
    3c10:	e5d43046 	ldrb	r3, [r4, #70]	; 0x46                         
    3c14:	0a000005 	beq	3c30 <rtems_termios_read+0x124>               
					if (tty->termios.c_cc[VTIME] && tty->ccount) {                   
    3c18:	e3530000 	cmp	r3, #0                                        
    3c1c:	0a00000a 	beq	3c4c <rtems_termios_read+0x140>               
    3c20:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
    3c24:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3c28:	0a000007 	beq	3c4c <rtems_termios_read+0x140>               <== NOT EXECUTED
    3c2c:	ea000001 	b	3c38 <rtems_termios_read+0x12c>                 <== NOT EXECUTED
							break;                                                         
						}                                                               
					}                                                                
				}                                                                 
				else {                                                            
					if (!tty->termios.c_cc[VTIME])                                   
    3c30:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3c34:	0a00006c 	beq	3dec <rtems_termios_read+0x2e0>               <== NOT EXECUTED
						break;                                                          
					now = rtems_clock_get_ticks_since_boot();                        
    3c38:	eb0003cb 	bl	4b6c <rtems_clock_get_ticks_since_boot>        <== NOT EXECUTED
					if ((now - then) > tty->vtimeTicks) {                            
    3c3c:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          <== NOT EXECUTED
    3c40:	e0680000 	rsb	r0, r8, r0                                    <== NOT EXECUTED
    3c44:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    3c48:	8a000067 	bhi	3dec <rtems_termios_read+0x2e0>               <== NOT EXECUTED
						break;                                                          
					}                                                                
				}                                                                 
				rtems_task_wake_after (1);                                        
    3c4c:	e3a00001 	mov	r0, #1                                        
    3c50:	eb00067b 	bl	5644 <rtems_task_wake_after>                   
    3c54:	eaffffe6 	b	3bf4 <rtems_termios_read+0xe8>                  
			}                                                                  
			else {                                                             
				siproc (n, tty);                                                  
    3c58:	e20000ff 	and	r0, r0, #255	; 0xff                           <== NOT EXECUTED
    3c5c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    3c60:	ebffff46 	bl	3980 <siproc>                                  <== NOT EXECUTED
				if (tty->ccount >= tty->termios.c_cc[VMIN])                       
    3c64:	e5d43047 	ldrb	r3, [r4, #71]	; 0x47                         <== NOT EXECUTED
    3c68:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
    3c6c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    3c70:	aa00005d 	bge	3dec <rtems_termios_read+0x2e0>               <== NOT EXECUTED
					break;                                                           
				if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])          
    3c74:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3c78:	0affffdd 	beq	3bf4 <rtems_termios_read+0xe8>                <== NOT EXECUTED
    3c7c:	e5d43046 	ldrb	r3, [r4, #70]	; 0x46                         <== NOT EXECUTED
    3c80:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3c84:	0affffda 	beq	3bf4 <rtems_termios_read+0xe8>                <== NOT EXECUTED
    3c88:	eaffffd7 	b	3bec <rtems_termios_read+0xe0>                  <== 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;         
    3c8c:	e5948074 	ldr	r8, [r4, #116]	; 0x74                         <== NOT EXECUTED
			  if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))                  
			       ==                (FL_MDXON | FL_ISNTXOF))                  
			      && ((tty->rawOutBufState == rob_idle)                        
				  || (tty->flow_ctrl & FL_OSTOP))) {                              
			    /* XON should be sent now... */                                
			    (*tty->device.write)(tty->minor,                               
    3c90:	e284b049 	add	fp, r4, #73	; 0x49                            <== NOT EXECUTED
    3c94:	e3a0a001 	mov	sl, #1                                        <== NOT EXECUTED
                                                                      
	while ( wait ) {                                                     
		/*                                                                  
		 * Process characters read from raw queue                           
		 */                                                                 
		while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&                
    3c98:	e59f91b4 	ldr	r9, [pc, #436]	; 3e54 <rtems_termios_read+0x348><== NOT EXECUTED
    3c9c:	ea000041 	b	3da8 <rtems_termios_read+0x29c>                 <== NOT EXECUTED
                       (tty->ccount < (CBUFSIZE-1))) {                
			unsigned char c;                                                   
			unsigned int newHead;                                              
                                                                      
			newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;           
    3ca0:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    3ca4:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
    3ca8:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
    3cac:	eb004be2 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
			c = tty->rawInBuf.theBuf[newHead];                                 
    3cb0:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
    3cb4:	e7d38000 	ldrb	r8, [r3, r0]                                 <== NOT EXECUTED
			tty->rawInBuf.Head = newHead;                                      
    3cb8:	e584005c 	str	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
			if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)                
    3cbc:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
    3cc0:	e5942064 	ldr	r2, [r4, #100]	; 0x64                         <== NOT EXECUTED
    3cc4:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
    3cc8:	e0600003 	rsb	r0, r0, r3                                    <== NOT EXECUTED
    3ccc:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
    3cd0:	eb004bd9 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
    3cd4:	e59430bc 	ldr	r3, [r4, #188]	; 0xbc                         <== NOT EXECUTED
    3cd8:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    3cdc:	2a00001f 	bcs	3d60 <rtems_termios_read+0x254>               <== NOT EXECUTED
			    % tty->rawInBuf.Size)                                          
			   < tty->lowwater) {                                              
			  tty->flow_ctrl &= ~FL_IREQXOF;                                   
    3ce0:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3ce4:	e3c33001 	bic	r3, r3, #1                                    <== NOT EXECUTED
    3ce8:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
			  /* if tx stopped and XON should be sent... */                    
			  if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))                  
    3cec:	e59f3164 	ldr	r3, [pc, #356]	; 3e58 <rtems_termios_read+0x34c><== NOT EXECUTED
    3cf0:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3cf4:	e59f015c 	ldr	r0, [pc, #348]	; 3e58 <rtems_termios_read+0x34c><== NOT EXECUTED
    3cf8:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
    3cfc:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
    3d00:	1a00000b 	bne	3d34 <rtems_termios_read+0x228>               <== NOT EXECUTED
    3d04:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
    3d08:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    3d0c:	0a000002 	beq	3d1c <rtems_termios_read+0x210>               <== NOT EXECUTED
			       ==                (FL_MDXON | FL_ISNTXOF))                  
			      && ((tty->rawOutBufState == rob_idle)                        
				  || (tty->flow_ctrl & FL_OSTOP))) {                              
    3d10:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== 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))                  
    3d14:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
    3d18:	0a000005 	beq	3d34 <rtems_termios_read+0x228>               <== NOT EXECUTED
			       ==                (FL_MDXON | FL_ISNTXOF))                  
			      && ((tty->rawOutBufState == rob_idle)                        
				  || (tty->flow_ctrl & FL_OSTOP))) {                              
			    /* XON should be sent now... */                                
			    (*tty->device.write)(tty->minor,                               
    3d1c:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    3d20:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
    3d24:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    3d28:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3d2c:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
    3d30:	ea00000a 	b	3d60 <rtems_termios_read+0x254>                 <== NOT EXECUTED
				(void *)&(tty->termios.c_cc[VSTART]),                             
				1);                                                               
			  }                                                                
			  else if (tty->flow_ctrl & FL_MDRTS) {                            
    3d34:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    3d38:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
    3d3c:	0a000007 	beq	3d60 <rtems_termios_read+0x254>               <== NOT EXECUTED
			    tty->flow_ctrl &= ~FL_IRTSOFF;                                 
    3d40:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
			    /* activate RTS line */                                        
			    if (tty->device.startRemoteTx != NULL) {                       
    3d44:	e59430b0 	ldr	r3, [r4, #176]	; 0xb0                         <== NOT EXECUTED
			    (*tty->device.write)(tty->minor,                               
				(void *)&(tty->termios.c_cc[VSTART]),                             
				1);                                                               
			  }                                                                
			  else if (tty->flow_ctrl & FL_MDRTS) {                            
			    tty->flow_ctrl &= ~FL_IRTSOFF;                                 
    3d48:	e3c22004 	bic	r2, r2, #4                                    <== NOT EXECUTED
			    /* activate RTS line */                                        
			    if (tty->device.startRemoteTx != NULL) {                       
    3d4c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
			    (*tty->device.write)(tty->minor,                               
				(void *)&(tty->termios.c_cc[VSTART]),                             
				1);                                                               
			  }                                                                
			  else if (tty->flow_ctrl & FL_MDRTS) {                            
			    tty->flow_ctrl &= ~FL_IRTSOFF;                                 
    3d50:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
			    /* activate RTS line */                                        
			    if (tty->device.startRemoteTx != NULL) {                       
			      tty->device.startRemoteTx(tty->minor);                       
    3d54:	15940010 	ldrne	r0, [r4, #16]                               <== NOT EXECUTED
    3d58:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    3d5c:	112fff13 	bxne	r3                                           <== NOT EXECUTED
			    }                                                              
			  }                                                                
			}                                                                  
                                                                      
			/* continue processing new character */                            
			if (tty->termios.c_lflag & ICANON) {                               
    3d60:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
    3d64:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
    3d68:	0a000005 	beq	3d84 <rtems_termios_read+0x278>               <== NOT EXECUTED
				if  (siproc (c, tty))                                             
    3d6c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    3d70:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    3d74:	ebffff01 	bl	3980 <siproc>                                  <== NOT EXECUTED
    3d78:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    3d7c:	1a000007 	bne	3da0 <rtems_termios_read+0x294>               <== NOT EXECUTED
    3d80:	ea000007 	b	3da4 <rtems_termios_read+0x298>                 <== NOT EXECUTED
					wait = 0;                                                        
			}                                                                  
			else {                                                             
				siproc (c, tty);                                                  
    3d84:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    3d88:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    3d8c:	ebfffefb 	bl	3980 <siproc>                                  <== NOT EXECUTED
				if (tty->ccount >= tty->termios.c_cc[VMIN])                       
    3d90:	e5d43047 	ldrb	r3, [r4, #71]	; 0x47                         <== NOT EXECUTED
    3d94:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
    3d98:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    3d9c:	ba000000 	blt	3da4 <rtems_termios_read+0x298>               <== NOT EXECUTED
    3da0:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
					wait = 0;                                                        
			}                                                                  
			timeout = tty->rawInBufSemaphoreTimeout;                           
    3da4:	e5948070 	ldr	r8, [r4, #112]	; 0x70                         <== NOT EXECUTED
                                                                      
	while ( wait ) {                                                     
		/*                                                                  
		 * Process characters read from raw queue                           
		 */                                                                 
		while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&                
    3da8:	e594205c 	ldr	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    3dac:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
    3db0:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    3db4:	0a000004 	beq	3dcc <rtems_termios_read+0x2c0>               <== NOT EXECUTED
    3db8:	e5993000 	ldr	r3, [r9]                                      <== NOT EXECUTED
    3dbc:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
    3dc0:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    3dc4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    3dc8:	baffffb4 	blt	3ca0 <rtems_termios_read+0x194>               <== NOT EXECUTED
		}                                                                   
                                                                      
		/*                                                                  
		 * Wait for characters                                              
		 */                                                                 
		if ( wait ) {                                                       
    3dcc:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
    3dd0:	0a000005 	beq	3dec <rtems_termios_read+0x2e0>               <== NOT EXECUTED
			sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,              
    3dd4:	e2840068 	add	r0, r4, #104	; 0x68                           <== NOT EXECUTED
    3dd8:	e8900003 	ldm	r0, {r0, r1}                                  <== NOT EXECUTED
    3ddc:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
    3de0:	eb0004ed 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
				tty->rawInBufSemaphoreOptions,                                    
				timeout);                                                         
			if (sc != RTEMS_SUCCESSFUL)                                        
    3de4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    3de8:	0affffee 	beq	3da8 <rtems_termios_read+0x29c>               <== NOT EXECUTED
{                                                                     
	rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;         
	rtems_status_code sc;                                                
	int               wait = (int)1;                                     
                                                                      
	while ( wait ) {                                                     
    3dec:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    3df0:	ea000007 	b	3e14 <rtems_termios_read+0x308>                 <== NOT EXECUTED
			sc = fillBufferQueue (tty);                                        
		if (sc != RTEMS_SUCCESSFUL)                                         
			tty->cindex = tty->ccount = 0;                                     
	}                                                                    
	while (count && (tty->cindex < tty->ccount)) {                       
		*buffer++ = tty->cbuf[tty->cindex++];                               
    3df4:	e594101c 	ldr	r1, [r4, #28]                                 <== NOT EXECUTED
    3df8:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
    3dfc:	e7d11002 	ldrb	r1, [r1, r2]                                 <== NOT EXECUTED
    3e00:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    3e04:	e7c01003 	strb	r1, [r0, r3]                                 <== NOT EXECUTED
    3e08:	e5842024 	str	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
		count--;                                                            
    3e0c:	e2477001 	sub	r7, r7, #1                                    <== NOT EXECUTED
    3e10:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
		else                                                                
			sc = fillBufferQueue (tty);                                        
		if (sc != RTEMS_SUCCESSFUL)                                         
			tty->cindex = tty->ccount = 0;                                     
	}                                                                    
	while (count && (tty->cindex < tty->ccount)) {                       
    3e14:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    3e18:	0a000003 	beq	3e2c <rtems_termios_read+0x320>               <== NOT EXECUTED
    3e1c:	e2841020 	add	r1, r4, #32                                   <== NOT EXECUTED
    3e20:	e8910006 	ldm	r1, {r1, r2}                                  <== NOT EXECUTED
    3e24:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
    3e28:	bafffff1 	blt	3df4 <rtems_termios_read+0x2e8>               <== NOT EXECUTED
		*buffer++ = tty->cbuf[tty->cindex++];                               
		count--;                                                            
	}                                                                    
	args->bytes_moved = args->count - count;                             
    3e2c:	e5953010 	ldr	r3, [r5, #16]                                 <== NOT EXECUTED
    3e30:	e0677003 	rsb	r7, r7, r3                                    <== NOT EXECUTED
    3e34:	e5857018 	str	r7, [r5, #24]                                 <== NOT EXECUTED
	tty->tty_rcvwakeup = 0;                                              
    3e38:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    3e3c:	e58430e4 	str	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
	rtems_semaphore_release (tty->isem);                                 
    3e40:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
    3e44:	eb00051a 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
	return sc;                                                           
}                                                                     
    3e48:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    3e4c:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      <== NOT EXECUTED
                                                                      

00002e2c <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))
    2e2c:	e59020b8 	ldr	r2, [r0, #184]	; 0xb8                         <== NOT EXECUTED
    2e30:	e59f31c8 	ldr	r3, [pc, #456]	; 3000 <rtems_termios_refill_transmitter+0x1d4><== NOT EXECUTED
    2e34:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
    2e38:	e59f21c4 	ldr	r2, [pc, #452]	; 3004 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
    2e3c:	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)      
{                                                                     
    2e40:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
    2e44:	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))          
    2e48:	1a00000c 	bne	2e80 <rtems_termios_refill_transmitter+0x54>  <== NOT EXECUTED
	    == (FL_MDXOF | FL_IREQXOF)) {                                    
	  /* XOFF should be sent now... */                                   
	  (*tty->device.write)(tty->minor,                                   
    2e4c:	e284104a 	add	r1, r4, #74	; 0x4a                            <== NOT EXECUTED
    2e50:	e2422b01 	sub	r2, r2, #1024	; 0x400                         <== NOT EXECUTED
    2e54:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
    2e58:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    2e5c:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    2e60:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
    2e64:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
    2e68:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
			       (void *)&(tty->termios.c_cc[VSTOP]), 1);                    
                                                                      
	  rtems_interrupt_disable(level);                                    
	  tty->t_dqlen--;                                                    
    2e6c:	e5942090 	ldr	r2, [r4, #144]	; 0x90                         <== NOT EXECUTED
	  tty->flow_ctrl |= FL_ISNTXOF;                                      
    2e70:	e59410b8 	ldr	r1, [r4, #184]	; 0xb8                         <== NOT EXECUTED
	  /* XOFF should be sent now... */                                   
	  (*tty->device.write)(tty->minor,                                   
			       (void *)&(tty->termios.c_cc[VSTOP]), 1);                    
                                                                      
	  rtems_interrupt_disable(level);                                    
	  tty->t_dqlen--;                                                    
    2e74:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
	  tty->flow_ctrl |= FL_ISNTXOF;                                      
    2e78:	e3811002 	orr	r1, r1, #2                                    <== NOT EXECUTED
    2e7c:	ea00000f 	b	2ec0 <rtems_termios_refill_transmitter+0x94>    <== NOT EXECUTED
	  rtems_interrupt_enable(level);                                     
                                                                      
	  nToSend = 1;                                                       
	}                                                                    
	else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))                
    2e80:	e59030b8 	ldr	r3, [r0, #184]	; 0xb8                         <== NOT EXECUTED
    2e84:	e2033003 	and	r3, r3, #3                                    <== NOT EXECUTED
    2e88:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
    2e8c:	1a000010 	bne	2ed4 <rtems_termios_refill_transmitter+0xa8>  <== 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,                                   
    2e90:	e2841049 	add	r1, r4, #73	; 0x49                            <== NOT EXECUTED
    2e94:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    2e98:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
    2e9c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    2ea0:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
    2ea4:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
    2ea8:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
    2eac:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
			       (void *)&(tty->termios.c_cc[VSTART]), 1);                   
                                                                      
	  rtems_interrupt_disable(level);                                    
	  tty->t_dqlen--;                                                    
    2eb0:	e5942090 	ldr	r2, [r4, #144]	; 0x90                         <== NOT EXECUTED
	  tty->flow_ctrl &= ~FL_ISNTXOF;                                     
    2eb4:	e59410b8 	ldr	r1, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		 */                                                                 
	  (*tty->device.write)(tty->minor,                                   
			       (void *)&(tty->termios.c_cc[VSTART]), 1);                   
                                                                      
	  rtems_interrupt_disable(level);                                    
	  tty->t_dqlen--;                                                    
    2eb8:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
	  tty->flow_ctrl &= ~FL_ISNTXOF;                                     
    2ebc:	e3c11002 	bic	r1, r1, #2                                    <== NOT EXECUTED
    2ec0:	e58410b8 	str	r1, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		 */                                                                 
	  (*tty->device.write)(tty->minor,                                   
			       (void *)&(tty->termios.c_cc[VSTART]), 1);                   
                                                                      
	  rtems_interrupt_disable(level);                                    
	  tty->t_dqlen--;                                                    
    2ec4:	e5842090 	str	r2, [r4, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    2ec8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    2ecc:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
    2ed0:	ea000048 	b	2ff8 <rtems_termios_refill_transmitter+0x1cc>   <== NOT EXECUTED
	  rtems_interrupt_enable(level);                                     
                                                                      
	  nToSend = 1;                                                       
	}                                                                    
	else {                                                               
	  if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {                
    2ed4:	e5902080 	ldr	r2, [r0, #128]	; 0x80                         <== NOT EXECUTED
    2ed8:	e5903084 	ldr	r3, [r0, #132]	; 0x84                         <== NOT EXECUTED
    2edc:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    2ee0:	1a000005 	bne	2efc <rtems_termios_refill_transmitter+0xd0>  <== NOT EXECUTED
	    /*                                                               
	     * buffer was empty                                              
	     */                                                              
	    if (tty->rawOutBufState == rob_wait) {                           
    2ee4:	e5903094 	ldr	r3, [r0, #148]	; 0x94                         <== NOT EXECUTED
    2ee8:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
	      /*                                                             
	       * this should never happen...                                 
	       */                                                            
	      rtems_semaphore_release (tty->rawOutBuf.Semaphore);            
    2eec:	0590008c 	ldreq	r0, [r0, #140]	; 0x8c                       <== NOT EXECUTED
    2ef0:	0b0008ef 	bleq	52b4 <rtems_semaphore_release>               <== NOT EXECUTED
    2ef4:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    2ef8:	ea00003e 	b	2ff8 <rtems_termios_refill_transmitter+0x1cc>   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    2efc:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
    2f00:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
    2f04:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
	    return 0;                                                        
	  }                                                                  
                                                                      
	  rtems_interrupt_disable(level);                                    
	  len = tty->t_dqlen;                                                
	  tty->t_dqlen = 0;                                                  
    2f08:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
	    }                                                                
	    return 0;                                                        
	  }                                                                  
                                                                      
	  rtems_interrupt_disable(level);                                    
	  len = tty->t_dqlen;                                                
    2f0c:	e5900090 	ldr	r0, [r0, #144]	; 0x90                         <== NOT EXECUTED
	  tty->t_dqlen = 0;                                                  
    2f10:	e5842090 	str	r2, [r4, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    2f14:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
	  rtems_interrupt_enable(level);                                     
                                                                      
	  newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;       
    2f18:	e5943084 	ldr	r3, [r4, #132]	; 0x84                         <== NOT EXECUTED
    2f1c:	e5941088 	ldr	r1, [r4, #136]	; 0x88                         <== NOT EXECUTED
    2f20:	e0800003 	add	r0, r0, r3                                    <== NOT EXECUTED
    2f24:	eb004f44 	bl	16c3c <__umodsi3>                              <== NOT EXECUTED
	  tty->rawOutBuf.Tail = newTail;                                     
	  if (tty->rawOutBufState == rob_wait) {                             
    2f28:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
    2f2c:	e3530002 	cmp	r3, #2                                        <== 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;       
    2f30:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
	  tty->rawOutBuf.Tail = newTail;                                     
    2f34:	e5840084 	str	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
	  if (tty->rawOutBufState == rob_wait) {                             
	    /*                                                               
	     * wake up any pending writer task                               
	     */                                                              
	    rtems_semaphore_release (tty->rawOutBuf.Semaphore);              
    2f38:	0594008c 	ldreq	r0, [r4, #140]	; 0x8c                       <== NOT EXECUTED
    2f3c:	0b0008dc 	bleq	52b4 <rtems_semaphore_release>               <== NOT EXECUTED
	  }                                                                  
	  if (newTail == tty->rawOutBuf.Head) {                              
    2f40:	e5943080 	ldr	r3, [r4, #128]	; 0x80                         <== NOT EXECUTED
    2f44:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
    2f48:	1a00000a 	bne	2f78 <rtems_termios_refill_transmitter+0x14c> <== NOT EXECUTED
	    nToSend = 0;                                                     
                                                                      
	    /*                                                               
	     * check to see if snd wakeup callback was set                   
	     */                                                              
	    if ( tty->tty_snd.sw_pfn != NULL) {                              
    2f4c:	e59430d4 	ldr	r3, [r4, #212]	; 0xd4                         <== NOT EXECUTED
	  }                                                                  
	  if (newTail == tty->rawOutBuf.Head) {                              
	    /*                                                               
	     * Buffer has become empty                                       
	     */                                                              
	    tty->rawOutBufState = rob_idle;                                  
    2f50:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
	    nToSend = 0;                                                     
                                                                      
	    /*                                                               
	     * check to see if snd wakeup callback was set                   
	     */                                                              
	    if ( tty->tty_snd.sw_pfn != NULL) {                              
    2f54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
	  }                                                                  
	  if (newTail == tty->rawOutBuf.Head) {                              
	    /*                                                               
	     * Buffer has become empty                                       
	     */                                                              
	    tty->rawOutBufState = rob_idle;                                  
    2f58:	e5845094 	str	r5, [r4, #148]	; 0x94                         <== NOT EXECUTED
	    nToSend = 0;                                                     
                                                                      
	    /*                                                               
	     * check to see if snd wakeup callback was set                   
	     */                                                              
	    if ( tty->tty_snd.sw_pfn != NULL) {                              
    2f5c:	01a05003 	moveq	r5, r3                                      <== NOT EXECUTED
    2f60:	0a000023 	beq	2ff4 <rtems_termios_refill_transmitter+0x1c8> <== NOT EXECUTED
	      (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);    
    2f64:	e2840030 	add	r0, r4, #48	; 0x30                            <== NOT EXECUTED
    2f68:	e59410d8 	ldr	r1, [r4, #216]	; 0xd8                         <== NOT EXECUTED
    2f6c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    2f70:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    2f74:	ea00001e 	b	2ff4 <rtems_termios_refill_transmitter+0x1c8>   <== NOT EXECUTED
	    }                                                                
	  }                                                                  
	  /* check, whether output should stop due to received XOFF */       
	  else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))                
    2f78:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    2f7c:	e2033e21 	and	r3, r3, #528	; 0x210                          <== NOT EXECUTED
    2f80:	e3530e21 	cmp	r3, #528	; 0x210                              <== NOT EXECUTED
    2f84:	1a00000a 	bne	2fb4 <rtems_termios_refill_transmitter+0x188> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  asm volatile (                                                      
    2f88:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
    2f8c:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
    2f90:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
		   ==                (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;                                       
    2f94:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    2f98:	e3822020 	orr	r2, r2, #32                                   <== NOT EXECUTED
    2f9c:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
		  tty->rawOutBufState = rob_busy; /*apm*/                           
    2fa0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    2fa4:	e5842094 	str	r2, [r4, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  asm volatile (                                                      
    2fa8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    2fac:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    2fb0:	ea00000f 	b	2ff4 <rtems_termios_refill_transmitter+0x1c8>   <== NOT EXECUTED
	  }                                                                  
	  else {                                                             
	    /*                                                               
	     * Buffer not empty, start tranmitter                            
	     */                                                              
	    if (newTail > tty->rawOutBuf.Head)                               
    2fb4:	e5943080 	ldr	r3, [r4, #128]	; 0x80                         <== NOT EXECUTED
    2fb8:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
		    nToSend = tty->rawOutBuf.Size - newTail;                        
    2fbc:	85945088 	ldrhi	r5, [r4, #136]	; 0x88                       <== NOT EXECUTED
	    else                                                             
		    nToSend = tty->rawOutBuf.Head - newTail;                        
    2fc0:	95945080 	ldrls	r5, [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)) {                    
    2fc4:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
	     * Buffer not empty, start tranmitter                            
	     */                                                              
	    if (newTail > tty->rawOutBuf.Head)                               
		    nToSend = tty->rawOutBuf.Size - newTail;                        
	    else                                                             
		    nToSend = tty->rawOutBuf.Head - newTail;                        
    2fc8:	e0665005 	rsb	r5, r6, r5                                    <== 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)) {                    
    2fcc:	e3130c06 	tst	r3, #1536	; 0x600                             <== NOT EXECUTED
		    nToSend = 1;                                                    
	    }                                                                
	    tty->rawOutBufState = rob_busy; /*apm*/                          
	    (*tty->device.write)(tty->minor,                                 
    2fd0:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
	    else                                                             
		    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)) {                    
    2fd4:	13a05001 	movne	r5, #1                                      <== NOT EXECUTED
		    nToSend = 1;                                                    
	    }                                                                
	    tty->rawOutBufState = rob_busy; /*apm*/                          
    2fd8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    2fdc:	e5843094 	str	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
	    (*tty->device.write)(tty->minor,                                 
    2fe0:	e0811006 	add	r1, r1, r6                                    <== NOT EXECUTED
    2fe4:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    2fe8:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    2fec:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    2ff0:	e594f0a4 	ldr	pc, [r4, #164]	; 0xa4                         <== NOT EXECUTED
				 &tty->rawOutBuf.theBuf[newTail],                                 
				 nToSend);                                                        
	  }                                                                  
	  tty->rawOutBuf.Tail = newTail; /*apm*/                             
    2ff4:	e5846084 	str	r6, [r4, #132]	; 0x84                         <== NOT EXECUTED
	}                                                                    
	return nToSend;                                                      
}                                                                     
    2ff8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    2ffc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00004838 <rtems_termios_rxdaemon>: /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) {
    4838:	e92d40f3 	push	{r0, r1, r4, r5, r6, r7, lr}                 <== NOT EXECUTED
    483c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
	char c_buf;                                                          
	while (1) {                                                          
		/*                                                                  
		 * wait for rtems event                                             
		 */                                                                 
		rtems_event_receive((TERMIOS_RX_PROC_EVENT |                        
    4840:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
			if (c != EOF) {                                                    
				/*                                                                
				 * pollRead did call enqueue on its own                           
				 */                                                               
				c_buf = c;                                                        
				rtems_termios_enqueue_raw_characters (                            
    4844:	e28d6007 	add	r6, sp, #7                                    <== NOT EXECUTED
	char c_buf;                                                          
	while (1) {                                                          
		/*                                                                  
		 * wait for rtems event                                             
		 */                                                                 
		rtems_event_receive((TERMIOS_RX_PROC_EVENT |                        
    4848:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
    484c:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
    4850:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    4854:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
    4858:	eb0000e0 	bl	4be0 <rtems_event_receive>                     <== NOT EXECUTED
				     TERMIOS_RX_TERMINATE_EVENT),                                 
				    RTEMS_EVENT_ANY | RTEMS_WAIT,                                 
				    RTEMS_NO_TIMEOUT,                                             
				    &the_event);                                                  
		if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {                
    485c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    4860:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
    4864:	0a000003 	beq	4878 <rtems_termios_rxdaemon+0x40>            <== NOT EXECUTED
			tty->rxTaskId = 0;                                                 
    4868:	e58450c4 	str	r5, [r4, #196]	; 0xc4                         <== NOT EXECUTED
			rtems_task_delete(RTEMS_SELF);                                     
    486c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    4870:	eb000308 	bl	5498 <rtems_task_delete>                       <== NOT EXECUTED
    4874:	eafffff3 	b	4848 <rtems_termios_rxdaemon+0x10>              <== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * do something                                                    
			 */                                                                
			c = tty->device.pollRead(tty->minor);                              
    4878:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
    487c:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    4880:	e594f0a0 	ldr	pc, [r4, #160]	; 0xa0                         <== NOT EXECUTED
			if (c != EOF) {                                                    
    4884:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * do something                                                    
			 */                                                                
			c = tty->device.pollRead(tty->minor);                              
    4888:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
			if (c != EOF) {                                                    
    488c:	0affffed 	beq	4848 <rtems_termios_rxdaemon+0x10>            <== NOT EXECUTED
				/*                                                                
				 * pollRead did call enqueue on its own                           
				 */                                                               
				c_buf = c;                                                        
				rtems_termios_enqueue_raw_characters (                            
    4890:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    4894:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    4898:	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;                                                        
    489c:	e5cd3007 	strb	r3, [sp, #7]                                 <== NOT EXECUTED
				rtems_termios_enqueue_raw_characters (                            
    48a0:	ebfff9f4 	bl	3078 <rtems_termios_enqueue_raw_characters>    <== NOT EXECUTED
    48a4:	eaffffe7 	b	4848 <rtems_termios_rxdaemon+0x10>              <== NOT EXECUTED
                                                                      

00002e20 <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);
    2e20:	e59000c4 	ldr	r0, [r0, #196]	; 0xc4                         <== NOT EXECUTED
    2e24:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
    2e28:	ea0007c8 	b	4d50 <rtems_event_send>                         <== NOT EXECUTED
                                                                      

000047cc <rtems_termios_txdaemon>: /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) {
    47cc:	e92d40f1 	push	{r0, r4, r5, r6, r7, lr}                     <== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * call any line discipline start function                         
			 */                                                                
			if (rtems_termios_linesw[tty->t_line].l_start != NULL) {           
    47d0:	e59f705c 	ldr	r7, [pc, #92]	; 4834 <rtems_termios_txdaemon+0x68><== NOT EXECUTED
                                                                      
/*                                                                    
 * this task actually processes any transmit events                   
 */                                                                   
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{                                                                     
    47d4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
	while (1) {                                                          
		/*                                                                  
		 * wait for rtems event                                             
		 */                                                                 
		rtems_event_receive((TERMIOS_TX_START_EVENT |                       
    47d8:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    47dc:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
    47e0:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
    47e4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    47e8:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
    47ec:	eb0000fb 	bl	4be0 <rtems_event_receive>                     <== NOT EXECUTED
				     TERMIOS_TX_TERMINATE_EVENT),                                 
				    RTEMS_EVENT_ANY | RTEMS_WAIT,                                 
				    RTEMS_NO_TIMEOUT,                                             
				    &the_event);                                                  
		if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {                
    47f0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    47f4:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
		else {                                                              
			/*                                                                 
			 * 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);                   
    47f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
		rtems_event_receive((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) {                
    47fc:	0a000003 	beq	4810 <rtems_termios_txdaemon+0x44>            <== NOT EXECUTED
			tty->txTaskId = 0;                                                 
    4800:	e58450c8 	str	r5, [r4, #200]	; 0xc8                         <== NOT EXECUTED
			rtems_task_delete(RTEMS_SELF);                                     
    4804:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    4808:	eb000322 	bl	5498 <rtems_task_delete>                       <== NOT EXECUTED
    480c:	eafffff2 	b	47dc <rtems_termios_txdaemon+0x10>              <== NOT EXECUTED
		}                                                                   
		else {                                                              
			/*                                                                 
			 * call any line discipline start function                         
			 */                                                                
			if (rtems_termios_linesw[tty->t_line].l_start != NULL) {           
    4810:	e59430cc 	ldr	r3, [r4, #204]	; 0xcc                         <== NOT EXECUTED
    4814:	e0873283 	add	r3, r7, r3, lsl #5                            <== NOT EXECUTED
    4818:	e5933014 	ldr	r3, [r3, #20]                                 <== NOT EXECUTED
    481c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
				rtems_termios_linesw[tty->t_line].l_start(tty);                   
    4820:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    4824:	112fff13 	bxne	r3                                           <== NOT EXECUTED
			}                                                                  
			/*                                                                 
			 * try to push further characters to device                        
			 */                                                                
			rtems_termios_refill_transmitter(tty);                             
    4828:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    482c:	ebfff97e 	bl	2e2c <rtems_termios_refill_transmitter>        <== NOT EXECUTED
    4830:	eaffffe9 	b	47dc <rtems_termios_txdaemon+0x10>              <== NOT EXECUTED
                                                                      

000039e0 <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;
    39e0:	e5903000 	ldr	r3, [r0]                                      
	rtems_termios_puts (&c, 1, tty);                                     
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_write (void *arg)                                       
{                                                                     
    39e4:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
	rtems_libio_rw_args_t *args = arg;                                   
	struct rtems_termios_tty *tty = args->iop->data1;                    
    39e8:	e5935034 	ldr	r5, [r3, #52]	; 0x34                          
	rtems_status_code sc;                                                
                                                                      
	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    39ec:	e3a01000 	mov	r1, #0                                        
	rtems_termios_puts (&c, 1, tty);                                     
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_write (void *arg)                                       
{                                                                     
    39f0:	e1a04000 	mov	r4, r0                                        
	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);
    39f4:	e1a02001 	mov	r2, r1                                        
    39f8:	e5950018 	ldr	r0, [r5, #24]                                 
    39fc:	eb0005e6 	bl	519c <rtems_semaphore_obtain>                  
	if (sc != RTEMS_SUCCESSFUL)                                          
    3a00:	e2506000 	subs	r6, r0, #0                                   
    3a04:	1a000022 	bne	3a94 <rtems_termios_write+0xb4>               
		return sc;                                                          
	if (rtems_termios_linesw[tty->t_line].l_write != NULL) {             
    3a08:	e59520cc 	ldr	r2, [r5, #204]	; 0xcc                         
    3a0c:	e59f3088 	ldr	r3, [pc, #136]	; 3a9c <rtems_termios_write+0xbc>
    3a10:	e0833282 	add	r3, r3, r2, lsl #5                            
    3a14:	e593300c 	ldr	r3, [r3, #12]                                 
    3a18:	e3530000 	cmp	r3, #0                                        
    3a1c:	0a000005 	beq	3a38 <rtems_termios_write+0x58>               
		sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);           
    3a20:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    3a24:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    3a28:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
    3a2c:	e12fff13 	bx	r3                                             <== NOT EXECUTED
    3a30:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    3a34:	ea000014 	b	3a8c <rtems_termios_write+0xac>                 <== NOT EXECUTED
		rtems_semaphore_release (tty->osem);                                
		return sc;                                                          
	}                                                                    
	if (tty->termios.c_oflag & OPOST) {                                  
    3a38:	e5953034 	ldr	r3, [r5, #52]	; 0x34                          
    3a3c:	e3130001 	tst	r3, #1                                        
		uint32_t   count = args->count;                                     
    3a40:	15948010 	ldrne	r8, [r4, #16]                               
		char      *buffer = args->buffer;                                   
    3a44:	1594a00c 	ldrne	sl, [r4, #12]                               
    3a48:	11a07006 	movne	r7, r6                                      
	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) {                                  
    3a4c:	1a000004 	bne	3a64 <rtems_termios_write+0x84>               
    3a50:	ea000007 	b	3a74 <rtems_termios_write+0x94>                 <== NOT EXECUTED
		uint32_t   count = args->count;                                     
		char      *buffer = args->buffer;                                   
		while (count--)                                                     
			oproc (*buffer++, tty);                                            
    3a54:	e7da0007 	ldrb	r0, [sl, r7]                                 
    3a58:	ebfffe7a 	bl	3448 <oproc>                                   
    3a5c:	e2877001 	add	r7, r7, #1                                    
    3a60:	e2488001 	sub	r8, r8, #1                                    
		return sc;                                                          
	}                                                                    
	if (tty->termios.c_oflag & OPOST) {                                  
		uint32_t   count = args->count;                                     
		char      *buffer = args->buffer;                                   
		while (count--)                                                     
    3a64:	e3580000 	cmp	r8, #0                                        
			oproc (*buffer++, tty);                                            
    3a68:	e1a01005 	mov	r1, r5                                        
		return sc;                                                          
	}                                                                    
	if (tty->termios.c_oflag & OPOST) {                                  
		uint32_t   count = args->count;                                     
		char      *buffer = args->buffer;                                   
		while (count--)                                                     
    3a6c:	1afffff8 	bne	3a54 <rtems_termios_write+0x74>               
    3a70:	ea000003 	b	3a84 <rtems_termios_write+0xa4>                 
			oproc (*buffer++, tty);                                            
		args->bytes_moved = args->count;                                    
	}                                                                    
	else {                                                               
		rtems_termios_puts (args->buffer, args->count, tty);                
    3a74:	e284000c 	add	r0, r4, #12                                   <== NOT EXECUTED
    3a78:	e8900003 	ldm	r0, {r0, r1}                                  <== NOT EXECUTED
    3a7c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    3a80:	ebfffe2f 	bl	3344 <rtems_termios_puts>                      <== NOT EXECUTED
		args->bytes_moved = args->count;                                    
    3a84:	e5943010 	ldr	r3, [r4, #16]                                 
    3a88:	e5843018 	str	r3, [r4, #24]                                 
	}                                                                    
	rtems_semaphore_release (tty->osem);                                 
    3a8c:	e5950018 	ldr	r0, [r5, #24]                                 
    3a90:	eb000607 	bl	52b4 <rtems_semaphore_release>                 
	return sc;                                                           
}                                                                     
    3a94:	e1a00006 	mov	r0, r6                                        
    3a98:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

000064b0 <rtems_verror>: static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) {
    64b0:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
    int               local_errno = 0;                                
    int               chars_written = 0;                              
    rtems_status_code status;                                         
                                                                      
    if (error_flag & RTEMS_ERROR_PANIC)                               
    64b4:	e2107202 	ands	r7, r0, #536870912	; 0x20000000              <== NOT EXECUTED
static int rtems_verror(                                              
    rtems_error_code_t error_flag,                                    
    const char   *printf_format,                                      
    va_list      arglist                                              
)                                                                     
{                                                                     
    64b8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    64bc:	e1a09001 	mov	r9, r1                                        <== NOT EXECUTED
    64c0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
    int               local_errno = 0;                                
    int               chars_written = 0;                              
    rtems_status_code status;                                         
                                                                      
    if (error_flag & RTEMS_ERROR_PANIC)                               
    64c4:	0a00000d 	beq	6500 <rtems_verror+0x50>                      <== NOT EXECUTED
    {                                                                 
        if (rtems_panic_in_progress++)                                
    64c8:	e59f3160 	ldr	r3, [pc, #352]	; 6630 <rtems_verror+0x180>    <== NOT EXECUTED
    64cc:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
    64d0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    64d4:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    64d8:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    64dc:	0a000003 	beq	64f0 <rtems_verror+0x40>                      <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
    64e0:	e59f314c 	ldr	r3, [pc, #332]	; 6634 <rtems_verror+0x184>    <== NOT EXECUTED
    64e4:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
    64e8:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    64ec:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
            _Thread_Disable_dispatch();       /* disable task switches */
                                                                      
        /* don't aggravate things */                                  
        if (rtems_panic_in_progress > 2)                              
    64f0:	e59f3138 	ldr	r3, [pc, #312]	; 6630 <rtems_verror+0x180>    <== NOT EXECUTED
    64f4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    64f8:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
    64fc:	ca000049 	bgt	6628 <rtems_verror+0x178>                     <== NOT EXECUTED
            return 0;                                                 
    }                                                                 
                                                                      
    (void) fflush(stdout);  	    /* in case stdout/stderr same */     
    6500:	e59f3130 	ldr	r3, [pc, #304]	; 6638 <rtems_verror+0x188>    <== NOT EXECUTED
    6504:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    6508:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
    650c:	eb0030d6 	bl	1286c <fflush>                                 <== NOT EXECUTED
                                                                      
    status = error_flag & ~RTEMS_ERROR_MASK;                          
    if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */      
    6510:	e2165101 	ands	r5, r6, #1073741824	; 0x40000000             <== NOT EXECUTED
            return 0;                                                 
    }                                                                 
                                                                      
    (void) fflush(stdout);  	    /* in case stdout/stderr same */     
                                                                      
    status = error_flag & ~RTEMS_ERROR_MASK;                          
    6514:	e3c68207 	bic	r8, r6, #1879048192	; 0x70000000              <== NOT EXECUTED
    if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */      
    6518:	0a000001 	beq	6524 <rtems_verror+0x74>                      <== NOT EXECUTED
        local_errno = errno;                                          
    651c:	eb002fdf 	bl	124a0 <__errno>                                <== NOT EXECUTED
    6520:	e5905000 	ldr	r5, [r0]                                      <== 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);        
    6524:	e59fa10c 	ldr	sl, [pc, #268]	; 6638 <rtems_verror+0x188>    <== NOT EXECUTED
    6528:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
    652c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    6530:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
    6534:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
    6538:	eb0048f1 	bl	18904 <vfprintf>                               <== NOT EXECUTED
                                                                      
    if (status)                                                       
    653c:	e3580000 	cmp	r8, #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);        
    6540:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
    if (status)                                                       
    6544:	0a000008 	beq	656c <rtems_verror+0xbc>                      <== NOT EXECUTED
        chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
    6548:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
    654c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    6550:	e593800c 	ldr	r8, [r3, #12]                                 <== NOT EXECUTED
    6554:	ebffffd1 	bl	64a0 <rtems_status_text>                       <== NOT EXECUTED
    6558:	e59f10dc 	ldr	r1, [pc, #220]	; 663c <rtems_verror+0x18c>    <== NOT EXECUTED
    655c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
    6560:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    6564:	eb00317e 	bl	12b64 <fprintf>                                <== NOT EXECUTED
    6568:	e0844000 	add	r4, r4, r0                                    <== NOT EXECUTED
                                                                      
    if (local_errno)                                                  
    656c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    6570:	0a000015 	beq	65cc <rtems_verror+0x11c>                     <== NOT EXECUTED
    {                                                                 
      if ((local_errno > 0) && *strerror(local_errno))                
    6574:	da00000d 	ble	65b0 <rtems_verror+0x100>                     <== NOT EXECUTED
    6578:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    657c:	eb00348b 	bl	137b0 <strerror>                               <== NOT EXECUTED
    6580:	e5d03000 	ldrb	r3, [r0]                                     <== NOT EXECUTED
    6584:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    6588:	0a000008 	beq	65b0 <rtems_verror+0x100>                     <== NOT EXECUTED
        chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
    658c:	e59f30a4 	ldr	r3, [pc, #164]	; 6638 <rtems_verror+0x188>    <== NOT EXECUTED
    6590:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    6594:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    6598:	e593800c 	ldr	r8, [r3, #12]                                 <== NOT EXECUTED
    659c:	eb003483 	bl	137b0 <strerror>                               <== NOT EXECUTED
    65a0:	e59f1098 	ldr	r1, [pc, #152]	; 6640 <rtems_verror+0x190>    <== NOT EXECUTED
    65a4:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
    65a8:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
    65ac:	ea000004 	b	65c4 <rtems_verror+0x114>                       <== NOT EXECUTED
      else                                                            
        chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
    65b0:	e59f3080 	ldr	r3, [pc, #128]	; 6638 <rtems_verror+0x188>    <== NOT EXECUTED
    65b4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    65b8:	e59f1084 	ldr	r1, [pc, #132]	; 6644 <rtems_verror+0x194>    <== NOT EXECUTED
    65bc:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
    65c0:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    65c4:	eb003166 	bl	12b64 <fprintf>                                <== NOT EXECUTED
    65c8:	e0844000 	add	r4, r4, r0                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    chars_written += fprintf(stderr, "\n");                           
    65cc:	e59f8064 	ldr	r8, [pc, #100]	; 6638 <rtems_verror+0x188>    <== NOT EXECUTED
    65d0:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
    65d4:	e59f106c 	ldr	r1, [pc, #108]	; 6648 <rtems_verror+0x198>    <== NOT EXECUTED
    65d8:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
    65dc:	eb003160 	bl	12b64 <fprintf>                                <== NOT EXECUTED
                                                                      
    (void) fflush(stderr);                                            
    65e0:	e5983000 	ldr	r3, [r8]                                      <== 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");                           
    65e4:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
                                                                      
    (void) fflush(stderr);                                            
    65e8:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
    65ec:	eb00309e 	bl	1286c <fflush>                                 <== NOT EXECUTED
                                                                      
    if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))         
    65f0:	e3160203 	tst	r6, #805306368	; 0x30000000                   <== 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");                           
    65f4:	008a0004 	addeq	r0, sl, r4                                  <== NOT EXECUTED
                                                                      
    (void) fflush(stderr);                                            
                                                                      
    if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))         
    65f8:	08bd87f0 	popeq	{r4, r5, r6, r7, r8, r9, sl, pc}            <== NOT EXECUTED
    {                                                                 
        if (error_flag & RTEMS_ERROR_PANIC)                           
    65fc:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    6600:	0a000004 	beq	6618 <rtems_verror+0x168>                     <== NOT EXECUTED
        {                                                             
            rtems_error(0, "fatal error, exiting");                   
    6604:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    6608:	e59f103c 	ldr	r1, [pc, #60]	; 664c <rtems_verror+0x19c>     <== NOT EXECUTED
    660c:	eb00001b 	bl	6680 <rtems_error>                             <== NOT EXECUTED
            _exit(local_errno);                                       
    6610:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    6614:	eb0002f2 	bl	71e4 <_exit>                                   <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
            rtems_error(0, "fatal error, aborting");                  
    6618:	e59f1030 	ldr	r1, [pc, #48]	; 6650 <rtems_verror+0x1a0>     <== NOT EXECUTED
    661c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
    6620:	eb000016 	bl	6680 <rtems_error>                             <== NOT EXECUTED
            abort();                                                  
    6624:	eb002f94 	bl	1247c <abort>                                  <== NOT EXECUTED
    6628:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
        }                                                             
    }                                                                 
    return chars_written;                                             
}                                                                     
    662c:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

00025434 <scanInt>: /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) {
   25434:	e92d4ff1 	push	{r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}     
   25438:	e3a04000 	mov	r4, #0                                        
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
   2543c:	e59fb0d4 	ldr	fp, [pc, #212]	; 25518 <scanInt+0xe4>         
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
   25440:	e59f90d4 	ldr	r9, [pc, #212]	; 2551c <scanInt+0xe8>         
/*                                                                    
 * Extract an integer value from the database                         
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
   25444:	e58d1000 	str	r1, [sp]                                      
   25448:	e1a05000 	mov	r5, r0                                        
   2544c:	e3e08102 	mvn	r8, #-2147483648	; 0x80000000                 
   25450:	e1a07004 	mov	r7, r4                                        
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
   25454:	e3a0a00a 	mov	sl, #10                                       
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
   25458:	e5953004 	ldr	r3, [r5, #4]                                  
   2545c:	e2433001 	sub	r3, r3, #1                                    
   25460:	e3530000 	cmp	r3, #0                                        
   25464:	e5853004 	str	r3, [r5, #4]                                  
   25468:	a5953000 	ldrge	r3, [r5]                                    
   2546c:	a4d36001 	ldrbge	r6, [r3], #1                               
   25470:	a5853000 	strge	r3, [r5]                                    
   25474:	aa000003 	bge	25488 <scanInt+0x54>                          
   25478:	e59b0000 	ldr	r0, [fp]                                      <== NOT EXECUTED
   2547c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   25480:	eb007420 	bl	42508 <__srget_r>                              <== NOT EXECUTED
   25484:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    if (c == ':')                                                     
   25488:	e356003a 	cmp	r6, #58	; 0x3a                                
   2548c:	0a000019 	beq	254f8 <scanInt+0xc4>                          
      break;                                                          
    if (sign == 0) {                                                  
   25490:	e3540000 	cmp	r4, #0                                        
   25494:	1a000004 	bne	254ac <scanInt+0x78>                          
      if (c == '-') {                                                 
   25498:	e356002d 	cmp	r6, #45	; 0x2d                                
        sign = -1;                                                    
        limit++;                                                      
   2549c:	02888001 	addeq	r8, r8, #1                                  
   254a0:	03e04000 	mvneq	r4, #0                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
    if (c == ':')                                                     
      break;                                                          
    if (sign == 0) {                                                  
      if (c == '-') {                                                 
   254a4:	0affffeb 	beq	25458 <scanInt+0x24>                          
        sign = -1;                                                    
        limit++;                                                      
        continue;                                                     
   254a8:	e3a04001 	mov	r4, #1                                        
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
   254ac:	e5993000 	ldr	r3, [r9]                                      
   254b0:	e0833006 	add	r3, r3, r6                                    
   254b4:	e5d33001 	ldrb	r3, [r3, #1]                                 
   254b8:	e3130004 	tst	r3, #4                                        
   254bc:	0a000013 	beq	25510 <scanInt+0xdc>                          
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
   254c0:	e1a00008 	mov	r0, r8                                        
   254c4:	e3a0100a 	mov	r1, #10                                       
   254c8:	eb00be4a 	bl	54df8 <__aeabi_uidiv>                          
   254cc:	e1570000 	cmp	r7, r0                                        
   254d0:	8a00000e 	bhi	25510 <scanInt+0xdc>                          
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
    d = c - '0';                                                      
   254d4:	e2466030 	sub	r6, r6, #48	; 0x30                            
    if ((i > (limit / 10))                                            
   254d8:	1a000004 	bne	254f0 <scanInt+0xbc>                          
   254dc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   254e0:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
   254e4:	eb00bed7 	bl	55048 <__umodsi3>                              <== NOT EXECUTED
   254e8:	e1560000 	cmp	r6, r0                                        <== NOT EXECUTED
   254ec:	8a000007 	bhi	25510 <scanInt+0xdc>                          <== NOT EXECUTED
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
   254f0:	e027679a 	mla	r7, sl, r7, r6                                
   254f4:	eaffffd7 	b	25458 <scanInt+0x24>                            
  }                                                                   
  if (sign == 0)                                                      
   254f8:	e3540000 	cmp	r4, #0                                        
    return 0;                                                         
  *val = i * sign;                                                    
   254fc:	10030497 	mulne	r3, r7, r4                                  
   25500:	159d2000 	ldrne	r2, [sp]                                    
   25504:	13a00001 	movne	r0, #1                                      
   25508:	15823000 	strne	r3, [r2]                                    
  return 1;                                                           
   2550c:	1a000000 	bne	25514 <scanInt+0xe0>                          
   25510:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
   25514:	e8bd8ff8 	pop	{r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}      
                                                                      

00025520 <scanString>: /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) {
   25520:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
   25524:	e1a04002 	mov	r4, r2                                        
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
   25528:	e5922000 	ldr	r2, [r2]                                      
/*                                                                    
 * Extract a string value from the database                           
 */                                                                   
static int                                                            
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{                                                                     
   2552c:	e59d6018 	ldr	r6, [sp, #24]                                 
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
   25530:	e5812000 	str	r2, [r1]                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
   25534:	e59f70c0 	ldr	r7, [pc, #192]	; 255fc <scanString+0xdc>      
/*                                                                    
 * Extract a string value from the database                           
 */                                                                   
static int                                                            
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{                                                                     
   25538:	e1a05000 	mov	r5, r0                                        
   2553c:	e1a08003 	mov	r8, r3                                        
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
   25540:	e5953004 	ldr	r3, [r5, #4]                                  
   25544:	e2433001 	sub	r3, r3, #1                                    
   25548:	e3530000 	cmp	r3, #0                                        
   2554c:	e5853004 	str	r3, [r5, #4]                                  
   25550:	a5953000 	ldrge	r3, [r5]                                    
   25554:	a4d30001 	ldrbge	r0, [r3], #1                               
   25558:	a5853000 	strge	r3, [r5]                                    
   2555c:	b5970000 	ldrlt	r0, [r7]                                    
   25560:	b1a01005 	movlt	r1, r5                                      
   25564:	bb0073e7 	bllt	42508 <__srget_r>                            
    if (c == ':') {                                                   
   25568:	e350003a 	cmp	r0, #58	; 0x3a                                
   2556c:	1a000002 	bne	2557c <scanString+0x5c>                       
        if (nlFlag)                                                   
   25570:	e3560000 	cmp	r6, #0                                        
   25574:	0a000013 	beq	255c8 <scanString+0xa8>                       
   25578:	ea00001d 	b	255f4 <scanString+0xd4>                         <== NOT EXECUTED
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
   2557c:	e350000a 	cmp	r0, #10                                       
   25580:	1a000002 	bne	25590 <scanString+0x70>                       
        if (!nlFlag)                                                  
   25584:	e3560000 	cmp	r6, #0                                        
   25588:	1a00000e 	bne	255c8 <scanString+0xa8>                       
   2558c:	ea000018 	b	255f4 <scanString+0xd4>                         <== NOT EXECUTED
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == EOF)                                                     
   25590:	e3700001 	cmn	r0, #1                                        
   25594:	0a000016 	beq	255f4 <scanString+0xd4>                       
      return 0;                                                       
    if (*nleft < 2)                                                   
   25598:	e5983000 	ldr	r3, [r8]                                      
   2559c:	e3530001 	cmp	r3, #1                                        
   255a0:	9a000013 	bls	255f4 <scanString+0xd4>                       
      return 0;                                                       
    **bufp = c;                                                       
   255a4:	e5943000 	ldr	r3, [r4]                                      
   255a8:	e5c30000 	strb	r0, [r3]                                     
    ++(*bufp);                                                        
   255ac:	e5942000 	ldr	r2, [r4]                                      
    --(*nleft);                                                       
   255b0:	e5983000 	ldr	r3, [r8]                                      
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
   255b4:	e2822001 	add	r2, r2, #1                                    
    --(*nleft);                                                       
   255b8:	e2433001 	sub	r3, r3, #1                                    
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
   255bc:	e5842000 	str	r2, [r4]                                      
    --(*nleft);                                                       
   255c0:	e5883000 	str	r3, [r8]                                      
  }                                                                   
   255c4:	eaffffdd 	b	25540 <scanString+0x20>                         
  **bufp = '\0';                                                      
   255c8:	e5943000 	ldr	r3, [r4]                                      
   255cc:	e3a02000 	mov	r2, #0                                        
   255d0:	e5c32000 	strb	r2, [r3]                                     
  ++(*bufp);                                                          
   255d4:	e5942000 	ldr	r2, [r4]                                      
  --(*nleft);                                                         
   255d8:	e5983000 	ldr	r3, [r8]                                      
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
   255dc:	e2822001 	add	r2, r2, #1                                    
  --(*nleft);                                                         
   255e0:	e2433001 	sub	r3, r3, #1                                    
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
   255e4:	e5842000 	str	r2, [r4]                                      
  --(*nleft);                                                         
   255e8:	e5883000 	str	r3, [r8]                                      
   255ec:	e3a00001 	mov	r0, #1                                        
  return 1;                                                           
   255f0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
   255f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
   255f8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

00025600 <scangr>: FILE *fp, struct group *grp, char *buffer, size_t bufsize ) {
   25600:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
   25604:	e24dd014 	sub	sp, sp, #20                                   
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   25608:	e28d6008 	add	r6, sp, #8                                    
   2560c:	e28d5004 	add	r5, sp, #4                                    
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
   25610:	e58d2008 	str	r2, [sp, #8]                                  
   25614:	e58d3004 	str	r3, [sp, #4]                                  
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   25618:	e3a08000 	mov	r8, #0                                        
   2561c:	e1a02006 	mov	r2, r6                                        
   25620:	e1a03005 	mov	r3, r5                                        
   25624:	e58d8000 	str	r8, [sp]                                      
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
   25628:	e1a07000 	mov	r7, r0                                        
   2562c:	e1a04001 	mov	r4, r1                                        
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   25630:	ebffffba 	bl	25520 <scanString>                             
   25634:	e1500008 	cmp	r0, r8                                        
   25638:	0a00003b 	beq	2572c <scangr+0x12c>                          
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
   2563c:	e1a00007 	mov	r0, r7                                        
   25640:	e2841004 	add	r1, r4, #4                                    
   25644:	e1a02006 	mov	r2, r6                                        
   25648:	e1a03005 	mov	r3, r5                                        
   2564c:	e58d8000 	str	r8, [sp]                                      
   25650:	ebffffb2 	bl	25520 <scanString>                             
{                                                                     
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   25654:	e1500008 	cmp	r0, r8                                        
   25658:	0a000033 	beq	2572c <scangr+0x12c>                          
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &grgid)                                            
   2565c:	e1a00007 	mov	r0, r7                                        
   25660:	e28d1010 	add	r1, sp, #16                                   
   25664:	ebffff72 	bl	25434 <scanInt>                                
{                                                                     
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   25668:	e1500008 	cmp	r0, r8                                        
   2566c:	0a00002e 	beq	2572c <scangr+0x12c>                          
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &grgid)                                            
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
   25670:	e1a03005 	mov	r3, r5                                        
   25674:	e28d100c 	add	r1, sp, #12                                   
   25678:	e1a00007 	mov	r0, r7                                        
   2567c:	e1a02006 	mov	r2, r6                                        
   25680:	e3a05001 	mov	r5, #1                                        
   25684:	e58d5000 	str	r5, [sp]                                      
   25688:	ebffffa4 	bl	25520 <scanString>                             
{                                                                     
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   2568c:	e1500008 	cmp	r0, r8                                        
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &grgid)                                            
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
    return 0;                                                         
  grp->gr_gid = grgid;                                                
   25690:	11dd31b0 	ldrhne	r3, [sp, #16]                              
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
   25694:	159d100c 	ldrne	r1, [sp, #12]                               
  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;                                                
   25698:	11c430b8 	strhne	r3, [r4, #8]                               
{                                                                     
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   2569c:	1a000003 	bne	256b0 <scangr+0xb0>                           
   256a0:	ea000021 	b	2572c <scangr+0x12c>                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
    if(*cp == ',')                                                    
   256a4:	e352002c 	cmp	r2, #44	; 0x2c                                
      memcount++;                                                     
   256a8:	02855001 	addeq	r5, r5, #1                                  
   256ac:	e2888001 	add	r8, r8, #1                                    
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
   256b0:	e7d12008 	ldrb	r2, [r1, r8]                                 
   256b4:	e3520000 	cmp	r2, #0                                        
   256b8:	1afffff9 	bne	256a4 <scangr+0xa4>                           
  }                                                                   
                                                                      
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
   256bc:	e1a05105 	lsl	r5, r5, #2                                    
   256c0:	e59d3004 	ldr	r3, [sp, #4]                                  
   256c4:	e2855013 	add	r5, r5, #19                                   
   256c8:	e1530005 	cmp	r3, r5                                        
   256cc:	3a000016 	bcc	2572c <scangr+0x12c>                          
    return 0;                                                         
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
   256d0:	e59d3008 	ldr	r3, [sp, #8]                                  
   256d4:	e283300f 	add	r3, r3, #15                                   
   256d8:	e3c3300f 	bic	r3, r3, #15                                   
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
   256dc:	e5831000 	str	r1, [r3]                                      
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
    return 0;                                                         
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
   256e0:	e584300c 	str	r3, [r4, #12]                                 
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
   256e4:	e59d300c 	ldr	r3, [sp, #12]                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
    if(*cp == ',') {                                                  
      *cp = '\0';                                                     
   256e8:	e1a00002 	mov	r0, r2                                        
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
   256ec:	e2833001 	add	r3, r3, #1                                    
   256f0:	e2822001 	add	r2, r2, #1                                    
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
   256f4:	ea000005 	b	25710 <scangr+0x110>                            
    if(*cp == ',') {                                                  
   256f8:	e351002c 	cmp	r1, #44	; 0x2c                                
      *cp = '\0';                                                     
   256fc:	05430001 	strbeq	r0, [r3, #-1]                              
      grp->gr_mem[memcount++] = cp + 1;                               
   25700:	0594100c 	ldreq	r1, [r4, #12]                               
   25704:	07813102 	streq	r3, [r1, r2, lsl #2]                        
   25708:	02822001 	addeq	r2, r2, #1                                  
   2570c:	e2833001 	add	r3, r3, #1                                    
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
   25710:	e5531001 	ldrb	r1, [r3, #-1]                                
   25714:	e3510000 	cmp	r1, #0                                        
   25718:	1afffff6 	bne	256f8 <scangr+0xf8>                           
    if(*cp == ',') {                                                  
      *cp = '\0';                                                     
      grp->gr_mem[memcount++] = cp + 1;                               
    }                                                                 
  }                                                                   
  grp->gr_mem[memcount] = NULL;                                       
   2571c:	e594300c 	ldr	r3, [r4, #12]                                 
   25720:	e3a00001 	mov	r0, #1                                        
   25724:	e7831102 	str	r1, [r3, r2, lsl #2]                          
  return 1;                                                           
   25728:	ea000000 	b	25730 <scangr+0x130>                            
   2572c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
   25730:	e28dd014 	add	sp, sp, #20                                   
   25734:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

00025774 <scanpw>: FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) {
   25774:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
   25778:	e24dd014 	sub	sp, sp, #20                                   
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   2577c:	e28d7008 	add	r7, sp, #8                                    
   25780:	e28d6004 	add	r6, sp, #4                                    
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
   25784:	e58d2008 	str	r2, [sp, #8]                                  
   25788:	e58d3004 	str	r3, [sp, #4]                                  
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   2578c:	e3a08000 	mov	r8, #0                                        
   25790:	e1a02007 	mov	r2, r7                                        
   25794:	e1a03006 	mov	r3, r6                                        
   25798:	e58d8000 	str	r8, [sp]                                      
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
   2579c:	e1a05000 	mov	r5, r0                                        
   257a0:	e1a04001 	mov	r4, r1                                        
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   257a4:	ebffff5d 	bl	25520 <scanString>                             
   257a8:	e1500008 	cmp	r0, r8                                        
   257ac:	0a000038 	beq	25894 <scanpw+0x120>                          
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
   257b0:	e1a00005 	mov	r0, r5                                        
   257b4:	e2841004 	add	r1, r4, #4                                    
   257b8:	e1a02007 	mov	r2, r7                                        
   257bc:	e1a03006 	mov	r3, r6                                        
   257c0:	e58d8000 	str	r8, [sp]                                      
   257c4:	ebffff55 	bl	25520 <scanString>                             
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   257c8:	e1500008 	cmp	r0, r8                                        
   257cc:	0a000030 	beq	25894 <scanpw+0x120>                          
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &pwuid)                                            
   257d0:	e1a00005 	mov	r0, r5                                        
   257d4:	e28d1010 	add	r1, sp, #16                                   
   257d8:	ebffff15 	bl	25434 <scanInt>                                
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   257dc:	e1500008 	cmp	r0, r8                                        
   257e0:	0a00002b 	beq	25894 <scanpw+0x120>                          
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &pwuid)                                            
   || !scanInt(fp, &pwgid)                                            
   257e4:	e1a00005 	mov	r0, r5                                        
   257e8:	e28d100c 	add	r1, sp, #12                                   
   257ec:	ebffff10 	bl	25434 <scanInt>                                
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   257f0:	e1500008 	cmp	r0, r8                                        
   257f4:	0a000026 	beq	25894 <scanpw+0x120>                          
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &pwuid)                                            
   || !scanInt(fp, &pwgid)                                            
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
   257f8:	e1a00005 	mov	r0, r5                                        
   257fc:	e284100c 	add	r1, r4, #12                                   
   25800:	e1a02007 	mov	r2, r7                                        
   25804:	e1a03006 	mov	r3, r6                                        
   25808:	e58d8000 	str	r8, [sp]                                      
   2580c:	ebffff43 	bl	25520 <scanString>                             
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   25810:	e1500008 	cmp	r0, r8                                        
   25814:	0a00001e 	beq	25894 <scanpw+0x120>                          
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &pwuid)                                            
   || !scanInt(fp, &pwgid)                                            
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
   25818:	e1a00005 	mov	r0, r5                                        
   2581c:	e2841010 	add	r1, r4, #16                                   
   25820:	e1a02007 	mov	r2, r7                                        
   25824:	e1a03006 	mov	r3, r6                                        
   25828:	e58d8000 	str	r8, [sp]                                      
   2582c:	ebffff3b 	bl	25520 <scanString>                             
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   25830:	e1500008 	cmp	r0, r8                                        
   25834:	0a000016 	beq	25894 <scanpw+0x120>                          
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &pwuid)                                            
   || !scanInt(fp, &pwgid)                                            
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
   || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)             
   25838:	e1a00005 	mov	r0, r5                                        
   2583c:	e2841014 	add	r1, r4, #20                                   
   25840:	e1a02007 	mov	r2, r7                                        
   25844:	e1a03006 	mov	r3, r6                                        
   25848:	e58d8000 	str	r8, [sp]                                      
   2584c:	ebffff33 	bl	25520 <scanString>                             
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   25850:	e1500008 	cmp	r0, r8                                        
   25854:	0a00000e 	beq	25894 <scanpw+0x120>                          
   || !scanInt(fp, &pwuid)                                            
   || !scanInt(fp, &pwgid)                                            
   || !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))          
   25858:	e1a00005 	mov	r0, r5                                        
   2585c:	e1a02007 	mov	r2, r7                                        
   25860:	e1a03006 	mov	r3, r6                                        
   25864:	e3a05001 	mov	r5, #1                                        
   25868:	e2841018 	add	r1, r4, #24                                   
   2586c:	e58d5000 	str	r5, [sp]                                      
   25870:	ebffff2a 	bl	25520 <scanString>                             
  size_t bufsize                                                      
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   25874:	e1500008 	cmp	r0, r8                                        
   25878:	0a000005 	beq	25894 <scanpw+0x120>                          
   || !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;                                                
  pwd->pw_gid = pwgid;                                                
   2587c:	e1dd30bc 	ldrh	r3, [sp, #12]                                
   25880:	e1c430ba 	strh	r3, [r4, #10]                                
   || !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;                                                
   25884:	e1dd31b0 	ldrh	r3, [sp, #16]                                
  pwd->pw_gid = pwgid;                                                
   25888:	e1a00005 	mov	r0, r5                                        
   || !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;                                                
   2588c:	e1c430b8 	strh	r3, [r4, #8]                                 
  pwd->pw_gid = pwgid;                                                
  return 1;                                                           
   25890:	ea000000 	b	25898 <scanpw+0x124>                            
   25894:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
   25898:	e28dd014 	add	sp, sp, #20                                   
   2589c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
                                                                      

000253ec <setgid>: int setgid( gid_t gid ) { _POSIX_types_Gid = gid;
   253ec:	e59f300c 	ldr	r3, [pc, #12]	; 25400 <setgid+0x14>           <== NOT EXECUTED
   253f0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   253f4:	e1c303b4 	strh	r0, [r3, #52]	; 0x34                         <== NOT EXECUTED
  return 0;                                                           
}                                                                     
   253f8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   253fc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

000259a4 <setgrent>: return NULL; return &grent; } void setgrent(void) {
   259a4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  init_etc_passwd_group();                                            
   259a8:	ebffffcb 	bl	258dc <init_etc_passwd_group>                  <== NOT EXECUTED
                                                                      
  if (group_fp != NULL)                                               
   259ac:	e59f3020 	ldr	r3, [pc, #32]	; 259d4 <setgrent+0x30>         <== NOT EXECUTED
   259b0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   259b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    fclose(group_fp);                                                 
   259b8:	1b005d9d 	blne	3d034 <fclose>                               <== NOT EXECUTED
  group_fp = fopen("/etc/group", "r");                                
   259bc:	e59f0014 	ldr	r0, [pc, #20]	; 259d8 <setgrent+0x34>         <== NOT EXECUTED
   259c0:	e59f1014 	ldr	r1, [pc, #20]	; 259dc <setgrent+0x38>         <== NOT EXECUTED
   259c4:	eb005fbd 	bl	3d8c0 <fopen>                                  <== NOT EXECUTED
   259c8:	e59f3004 	ldr	r3, [pc, #4]	; 259d4 <setgrent+0x30>          <== NOT EXECUTED
   259cc:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
}                                                                     
   259d0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

00025b74 <setpwent>: return NULL; return &pwent; } void setpwent(void) {
   25b74:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  init_etc_passwd_group();                                            
   25b78:	ebffff57 	bl	258dc <init_etc_passwd_group>                  <== NOT EXECUTED
                                                                      
  if (passwd_fp != NULL)                                              
   25b7c:	e59f3020 	ldr	r3, [pc, #32]	; 25ba4 <setpwent+0x30>         <== NOT EXECUTED
   25b80:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
   25b84:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    fclose(passwd_fp);                                                
   25b88:	1b005d29 	blne	3d034 <fclose>                               <== NOT EXECUTED
  passwd_fp = fopen("/etc/passwd", "r");                              
   25b8c:	e59f0014 	ldr	r0, [pc, #20]	; 25ba8 <setpwent+0x34>         <== NOT EXECUTED
   25b90:	e59f1014 	ldr	r1, [pc, #20]	; 25bac <setpwent+0x38>         <== NOT EXECUTED
   25b94:	eb005f49 	bl	3d8c0 <fopen>                                  <== NOT EXECUTED
   25b98:	e59f3004 	ldr	r3, [pc, #4]	; 25ba4 <setpwent+0x30>          <== NOT EXECUTED
   25b9c:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
}                                                                     
   25ba0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

000077d4 <setuid>: int setuid( uid_t uid ) { _POSIX_types_Uid = uid;
    77d4:	e59f300c 	ldr	r3, [pc, #12]	; 77e8 <setuid+0x14>            <== NOT EXECUTED
    77d8:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    77dc:	e1c303b2 	strh	r0, [r3, #50]	; 0x32                         <== NOT EXECUTED
  return 0;                                                           
}                                                                     
    77e0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    77e4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

00003980 <siproc>: int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
    3980:	e591203c 	ldr	r2, [r1, #60]	; 0x3c                          <== NOT EXECUTED
    3984:	e59f3050 	ldr	r3, [pc, #80]	; 39dc <siproc+0x5c>            <== NOT EXECUTED
    3988:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
    398c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
/*                                                                    
 * Process input character, with semaphore.                           
 */                                                                   
static int                                                            
siproc (unsigned char c, struct rtems_termios_tty *tty)               
{                                                                     
    3990:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
    3994:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    3998:	e20050ff 	and	r5, r0, #255	; 0xff                           <== NOT EXECUTED
	int i;                                                               
                                                                      
	/*                                                                   
	 * Obtain output semaphore if character will be echoed               
	 */                                                                  
	if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
    399c:	0a00000b 	beq	39d0 <siproc+0x50>                            <== NOT EXECUTED
		rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);   
    39a0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    39a4:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    39a8:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
    39ac:	eb0005fa 	bl	519c <rtems_semaphore_obtain>                  <== NOT EXECUTED
		i = iproc (c, tty);                                                 
    39b0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    39b4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    39b8:	ebffff8b 	bl	37ec <iproc>                                   <== NOT EXECUTED
    39bc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
		rtems_semaphore_release (tty->osem);                                
    39c0:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
    39c4:	eb00063a 	bl	52b4 <rtems_semaphore_release>                 <== NOT EXECUTED
	}                                                                    
	else {                                                               
		i = iproc (c, tty);                                                 
	}                                                                    
	return i;                                                            
}                                                                     
    39c8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    39cc:	e8bd8030 	pop	{r4, r5, pc}                                  <== 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);                                                 
    39d0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
	}                                                                    
	return i;                                                            
}                                                                     
    39d4:	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);                                                 
    39d8:	eaffff83 	b	37ec <iproc>                                    <== NOT EXECUTED
                                                                      

00008e34 <stat>: int _STAT_NAME( const char *path, struct stat *buf ) {
    8e34:	e92d4070 	push	{r4, r5, r6, lr}                             
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
    8e38:	e2515000 	subs	r5, r1, #0                                   
                                                                      
int _STAT_NAME(                                                       
  const char  *path,                                                  
  struct stat *buf                                                    
)                                                                     
{                                                                     
    8e3c:	e24dd018 	sub	sp, sp, #24                                   
    8e40:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
    8e44:	1a000002 	bne	8e54 <stat+0x20>                              
    rtems_set_errno_and_return_minus_one( EFAULT );                   
    8e48:	eb00d02c 	bl	3cf00 <__errno>                                
    8e4c:	e3a0300e 	mov	r3, #14                                       
    8e50:	ea000018 	b	8eb8 <stat+0x84>                                
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ),      
    8e54:	eb00eb26 	bl	43af4 <strlen>                                 
    8e58:	e28d4004 	add	r4, sp, #4                                    
    8e5c:	e1a01000 	mov	r1, r0                                        
    8e60:	e3a0c001 	mov	ip, #1                                        
    8e64:	e1a00006 	mov	r0, r6                                        
    8e68:	e3a02000 	mov	r2, #0                                        
    8e6c:	e1a03004 	mov	r3, r4                                        
    8e70:	e58dc000 	str	ip, [sp]                                      
    8e74:	ebfff9f0 	bl	763c <rtems_filesystem_evaluate_path>          
                                           0, &loc, _STAT_FOLLOW_LINKS );
  if ( status != 0 )                                                  
    8e78:	e2501000 	subs	r1, r0, #0                                   
    8e7c:	1a00000e 	bne	8ebc <stat+0x88>                              
    return -1;                                                        
                                                                      
  if ( !loc.handlers->fstat_h ){                                      
    8e80:	e59d300c 	ldr	r3, [sp, #12]                                 
    8e84:	e5933018 	ldr	r3, [r3, #24]                                 
    8e88:	e3530000 	cmp	r3, #0                                        
    8e8c:	1a00000c 	bne	8ec4 <stat+0x90>                              
    rtems_filesystem_freenode( &loc );                                
    8e90:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
    8e94:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8e98:	0a000004 	beq	8eb0 <stat+0x7c>                              <== NOT EXECUTED
    8e9c:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    8ea0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    8ea4:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    8ea8:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    8eac:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    8eb0:	eb00d012 	bl	3cf00 <__errno>                                <== NOT EXECUTED
    8eb4:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    8eb8:	e5803000 	str	r3, [r0]                                      
    8ebc:	e3e05000 	mvn	r5, #0                                        
    8ec0:	ea000010 	b	8f08 <stat+0xd4>                                
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
    8ec4:	e3a02048 	mov	r2, #72	; 0x48                                
    8ec8:	e1a00005 	mov	r0, r5                                        
    8ecc:	eb00dd42 	bl	403dc <memset>                                 
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
    8ed0:	e1a01005 	mov	r1, r5                                        
    8ed4:	e59d300c 	ldr	r3, [sp, #12]                                 
    8ed8:	e1a00004 	mov	r0, r4                                        
    8edc:	e1a0e00f 	mov	lr, pc                                        
    8ee0:	e593f018 	ldr	pc, [r3, #24]                                 
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    8ee4:	e59d3010 	ldr	r3, [sp, #16]                                 
    8ee8:	e3530000 	cmp	r3, #0                                        
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
    8eec:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    8ef0:	0a000004 	beq	8f08 <stat+0xd4>                              
    8ef4:	e593301c 	ldr	r3, [r3, #28]                                 
    8ef8:	e3530000 	cmp	r3, #0                                        
    8efc:	11a00004 	movne	r0, r4                                      
    8f00:	11a0e00f 	movne	lr, pc                                      
    8f04:	112fff13 	bxne	r3                                           
                                                                      
  return status;                                                      
}                                                                     
    8f08:	e1a00005 	mov	r0, r5                                        
    8f0c:	e28dd018 	add	sp, sp, #24                                   
    8f10:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00026a68 <statvfs>: #include <sys/statvfs.h> int statvfs (const char *path, struct statvfs *sb) {
   26a68:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   26a6c:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
   26a70:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   26a74:	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 ) )
   26a78:	eb00741d 	bl	43af4 <strlen>                                 <== NOT EXECUTED
   26a7c:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
   26a80:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   26a84:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
   26a88:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
   26a8c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   26a90:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
   26a94:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
   26a98:	ebff82e7 	bl	763c <rtems_filesystem_evaluate_path>          <== NOT EXECUTED
   26a9c:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
   26aa0:	1a000007 	bne	26ac4 <statvfs+0x5c>                          <== NOT EXECUTED
    return -1;                                                        
                                                                      
  mt_entry      = loc.mt_entry;                                       
   26aa4:	e59d6014 	ldr	r6, [sp, #20]                                 <== NOT EXECUTED
  fs_mount_root = &mt_entry->mt_fs_root;                              
   26aa8:	e5963028 	ldr	r3, [r6, #40]	; 0x28                          <== NOT EXECUTED
   26aac:	e5933044 	ldr	r3, [r3, #68]	; 0x44                          <== NOT EXECUTED
   26ab0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26ab4:	1a000004 	bne	26acc <statvfs+0x64>                          <== NOT EXECUTED
                                                                      
  if ( !fs_mount_root->ops->statvfs_h )                               
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   26ab8:	eb005910 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   26abc:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   26ac0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   26ac4:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
   26ac8:	ea000010 	b	26b10 <statvfs+0xa8>                            <== NOT EXECUTED
                                                                      
  memset (sb, 0, sizeof (struct statvfs));                            
   26acc:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
   26ad0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   26ad4:	eb006640 	bl	403dc <memset>                                 <== NOT EXECUTED
                                                                      
  result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );    
   26ad8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   26adc:	e5963028 	ldr	r3, [r6, #40]	; 0x28                          <== NOT EXECUTED
   26ae0:	e286001c 	add	r0, r6, #28                                   <== NOT EXECUTED
   26ae4:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   26ae8:	e593f044 	ldr	pc, [r3, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26aec:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
   26af0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  if ( !fs_mount_root->ops->statvfs_h )                               
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  memset (sb, 0, sizeof (struct statvfs));                            
                                                                      
  result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );    
   26af4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26af8:	0a000004 	beq	26b10 <statvfs+0xa8>                          <== NOT EXECUTED
   26afc:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
   26b00:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26b04:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   26b08:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   26b0c:	112fff13 	bxne	r3                                           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
   26b10:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   26b14:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
   26b18:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

00026b68 <symlink>: int symlink( const char *actualpath, const char *sympath ) {
   26b68:	e92d4070 	push	{r4, r5, r6, lr}                             
   26b6c:	e1a05001 	mov	r5, r1                                        
   26b70:	e24dd01c 	sub	sp, sp, #28                                   
   26b74:	e1a06000 	mov	r6, r0                                        
  rtems_filesystem_location_info_t    loc;                            
  int                                 i;                              
  const char                         *name_start;                     
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
   26b78:	e28d1018 	add	r1, sp, #24                                   
   26b7c:	e1a00005 	mov	r0, r5                                        
   26b80:	e1a0200d 	mov	r2, sp                                        
   26b84:	ebff88e5 	bl	8f20 <rtems_filesystem_get_start_loc>          
                                                                      
  if ( !loc.ops->evalformake_h ) {                                    
   26b88:	e59d300c 	ldr	r3, [sp, #12]                                 
   26b8c:	e5933004 	ldr	r3, [r3, #4]                                  
   26b90:	e3530000 	cmp	r3, #0                                        
  rtems_filesystem_location_info_t    loc;                            
  int                                 i;                              
  const char                         *name_start;                     
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
   26b94:	e1a0400d 	mov	r4, sp                                        
                                                                      
  if ( !loc.ops->evalformake_h ) {                                    
   26b98:	0a000010 	beq	26be0 <symlink+0x78>                          
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
   26b9c:	e59d0018 	ldr	r0, [sp, #24]                                 
   26ba0:	e1a0100d 	mov	r1, sp                                        
   26ba4:	e0850000 	add	r0, r5, r0                                    
   26ba8:	e28d2014 	add	r2, sp, #20                                   
   26bac:	e1a0e00f 	mov	lr, pc                                        
   26bb0:	e12fff13 	bx	r3                                             
  if ( result != 0 )                                                  
   26bb4:	e3500000 	cmp	r0, #0                                        
   26bb8:	1a00000b 	bne	26bec <symlink+0x84>                          
    return -1;                                                        
                                                                      
  if ( !loc.ops->symlink_h ) {                                        
   26bbc:	e59d200c 	ldr	r2, [sp, #12]                                 
   26bc0:	e5923038 	ldr	r3, [r2, #56]	; 0x38                          
   26bc4:	e3530000 	cmp	r3, #0                                        
   26bc8:	1a000009 	bne	26bf4 <symlink+0x8c>                          
    rtems_filesystem_freenode( &loc );                                
   26bcc:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
   26bd0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26bd4:	11a0000d 	movne	r0, sp                                      <== NOT EXECUTED
   26bd8:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   26bdc:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   26be0:	eb0058c6 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   26be4:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   26be8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   26bec:	e3e05000 	mvn	r5, #0                                        
   26bf0:	ea00000d 	b	26c2c <symlink+0xc4>                            
  }                                                                   
                                                                      
  result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);      
   26bf4:	e1a01006 	mov	r1, r6                                        
   26bf8:	e1a0000d 	mov	r0, sp                                        
   26bfc:	e59d2014 	ldr	r2, [sp, #20]                                 
   26c00:	e1a0e00f 	mov	lr, pc                                        
   26c04:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26c08:	e59d300c 	ldr	r3, [sp, #12]                                 
   26c0c:	e3530000 	cmp	r3, #0                                        
  if ( !loc.ops->symlink_h ) {                                        
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);      
   26c10:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26c14:	0a000004 	beq	26c2c <symlink+0xc4>                          
   26c18:	e593301c 	ldr	r3, [r3, #28]                                 
   26c1c:	e3530000 	cmp	r3, #0                                        
   26c20:	11a0000d 	movne	r0, sp                                      
   26c24:	11a0e00f 	movne	lr, pc                                      
   26c28:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
   26c2c:	e1a00005 	mov	r0, r5                                        
   26c30:	e28dd01c 	add	sp, sp, #28                                   
   26c34:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00010f34 <tcsetattr>: int fd, int opt, struct termios *tp ) { switch (opt) {
   10f34:	e3510000 	cmp	r1, #0                                        
int tcsetattr(                                                        
  int             fd,                                                 
  int             opt,                                                
  struct termios *tp                                                  
)                                                                     
{                                                                     
   10f38:	e92d4030 	push	{r4, r5, lr}                                 
   10f3c:	e1a04002 	mov	r4, r2                                        
   10f40:	e1a05000 	mov	r5, r0                                        
  switch (opt) {                                                      
   10f44:	0a00000a 	beq	10f74 <tcsetattr+0x40>                        
   10f48:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
   10f4c:	0a000003 	beq	10f60 <tcsetattr+0x2c>                        <== NOT EXECUTED
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   10f50:	eb001052 	bl	150a0 <__errno>                                <== NOT EXECUTED
   10f54:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   10f58:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   10f5c:	ea000009 	b	10f88 <tcsetattr+0x54>                          <== NOT EXECUTED
                                                                      
  case TCSADRAIN:                                                     
    if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)                      
   10f60:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
   10f64:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   10f68:	eb000e29 	bl	14814 <ioctl>                                  <== NOT EXECUTED
   10f6c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   10f70:	ba000004 	blt	10f88 <tcsetattr+0x54>                        <== NOT EXECUTED
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
   10f74:	e1a00005 	mov	r0, r5                                        
   10f78:	e1a02004 	mov	r2, r4                                        
   10f7c:	e3a01002 	mov	r1, #2                                        
  }                                                                   
}                                                                     
   10f80:	e8bd4030 	pop	{r4, r5, lr}                                  
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
   10f84:	ea000e22 	b	14814 <ioctl>                                   
  }                                                                   
}                                                                     
   10f88:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   10f8c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

0000cca0 <unlink>: #include <rtems/seterr.h> int unlink( const char *path ) {
    cca0:	e92d4070 	push	{r4, r5, r6, lr}                             
    cca4:	e24dd030 	sub	sp, sp, #48	; 0x30                            
    cca8:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   * Get the node to be unlinked. Find the parent path first.         
   */                                                                 
                                                                      
  parentpathlen = rtems_filesystem_dirname ( path );                  
    ccac:	ebffd422 	bl	1d3c <rtems_filesystem_dirname>                
                                                                      
  if ( parentpathlen == 0 )                                           
    ccb0:	e2504000 	subs	r4, r0, #0                                   
    ccb4:	e28d3018 	add	r3, sp, #24                                   
    ccb8:	1a000005 	bne	ccd4 <unlink+0x34>                            
    rtems_filesystem_get_start_loc( path, &i, &parentloc );           
    ccbc:	e1a02003 	mov	r2, r3                                        
    ccc0:	e1a00006 	mov	r0, r6                                        
    ccc4:	e28d102c 	add	r1, sp, #44	; 0x2c                            
    ccc8:	ebffd81e 	bl	2d48 <rtems_filesystem_get_start_loc>          
    cccc:	e1a05004 	mov	r5, r4                                        
    ccd0:	ea000008 	b	ccf8 <unlink+0x58>                              
  else {                                                              
    result = rtems_filesystem_evaluate_path( path, parentpathlen,     
    ccd4:	e3a0c000 	mov	ip, #0                                        
    ccd8:	e1a00006 	mov	r0, r6                                        
    ccdc:	e1a01004 	mov	r1, r4                                        
    cce0:	e3a02002 	mov	r2, #2                                        
    cce4:	e58dc000 	str	ip, [sp]                                      
    cce8:	ebffd45a 	bl	1e58 <rtems_filesystem_evaluate_path>          
                                             RTEMS_LIBIO_PERMS_WRITE, 
                                             &parentloc,              
                                             false );                 
    if ( result != 0 )                                                
    ccec:	e3500000 	cmp	r0, #0                                        
    ccf0:	1a000072 	bne	cec0 <unlink+0x220>                           
    ccf4:	e3a05001 	mov	r5, #1                                        
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
    ccf8:	e28de018 	add	lr, sp, #24                                   
    ccfc:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
    cd00:	e28dc004 	add	ip, sp, #4                                    
    cd04:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
    cd08:	e59e3000 	ldr	r3, [lr]                                      
  name = path + parentpathlen;                                        
    cd0c:	e0864004 	add	r4, r6, r4                                    
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
    cd10:	e58c3000 	str	r3, [ip]                                      
  name = path + parentpathlen;                                        
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
    cd14:	e1a00004 	mov	r0, r4                                        
    cd18:	eb0005ae 	bl	e3d8 <strlen>                                  
    cd1c:	e1a01000 	mov	r1, r0                                        
    cd20:	e1a00004 	mov	r0, r4                                        
    cd24:	ebffd3f4 	bl	1cfc <rtems_filesystem_prefix_separators>      
    cd28:	e0846000 	add	r6, r4, r0                                    
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
    cd2c:	e1a00006 	mov	r0, r6                                        
    cd30:	eb0005a8 	bl	e3d8 <strlen>                                  
    cd34:	e28d4004 	add	r4, sp, #4                                    
    cd38:	e3a0c000 	mov	ip, #0                                        
    cd3c:	e1a01000 	mov	r1, r0                                        
    cd40:	e1a0200c 	mov	r2, ip                                        
    cd44:	e1a00006 	mov	r0, r6                                        
    cd48:	e1a03004 	mov	r3, r4                                        
    cd4c:	e58dc000 	str	ip, [sp]                                      
    cd50:	ebffd408 	bl	1d78 <rtems_filesystem_evaluate_relative_path> 
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
    cd54:	e3500000 	cmp	r0, #0                                        
    cd58:	0a00000b 	beq	cd8c <unlink+0xec>                            
    if ( free_parentloc )                                             
    cd5c:	e3550000 	cmp	r5, #0                                        
    cd60:	0a000056 	beq	cec0 <unlink+0x220>                           
      rtems_filesystem_freenode( &parentloc );                        
    cd64:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
    cd68:	e3530000 	cmp	r3, #0                                        
    cd6c:	0a000053 	beq	cec0 <unlink+0x220>                           
    cd70:	e593301c 	ldr	r3, [r3, #28]                                 
    cd74:	e3530000 	cmp	r3, #0                                        
    cd78:	0a000050 	beq	cec0 <unlink+0x220>                           
    cd7c:	e28d0018 	add	r0, sp, #24                                   
    cd80:	e1a0e00f 	mov	lr, pc                                        
    cd84:	e12fff13 	bx	r3                                             
    cd88:	ea00004c 	b	cec0 <unlink+0x220>                             
    return -1;                                                        
  }                                                                   
                                                                      
  if ( !loc.ops->node_type_h ) {                                      
    cd8c:	e59d2010 	ldr	r2, [sp, #16]                                 
    cd90:	e5923010 	ldr	r3, [r2, #16]                                 
    cd94:	e3530000 	cmp	r3, #0                                        
    cd98:	0a00001c 	beq	ce10 <unlink+0x170>                           
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
    cd9c:	e1a00004 	mov	r0, r4                                        
    cda0:	e1a0e00f 	mov	lr, pc                                        
    cda4:	e12fff13 	bx	r3                                             
    cda8:	e3500001 	cmp	r0, #1                                        
    cdac:	e59d2010 	ldr	r2, [sp, #16]                                 
    cdb0:	1a000013 	bne	ce04 <unlink+0x164>                           
    rtems_filesystem_freenode( &loc );                                
    cdb4:	e3520000 	cmp	r2, #0                                        
    cdb8:	0a000004 	beq	cdd0 <unlink+0x130>                           
    cdbc:	e592301c 	ldr	r3, [r2, #28]                                 
    cdc0:	e3530000 	cmp	r3, #0                                        
    cdc4:	11a00004 	movne	r0, r4                                      
    cdc8:	11a0e00f 	movne	lr, pc                                      
    cdcc:	112fff13 	bxne	r3                                           
    if ( free_parentloc )                                             
    cdd0:	e3550000 	cmp	r5, #0                                        
    cdd4:	0a000007 	beq	cdf8 <unlink+0x158>                           
      rtems_filesystem_freenode( &parentloc );                        
    cdd8:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
    cddc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    cde0:	0a000004 	beq	cdf8 <unlink+0x158>                           <== NOT EXECUTED
    cde4:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    cde8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    cdec:	128d0018 	addne	r0, sp, #24                                 <== NOT EXECUTED
    cdf0:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    cdf4:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EISDIR );                   
    cdf8:	eb000171 	bl	d3c4 <__errno>                                 
    cdfc:	e3a03015 	mov	r3, #21                                       
    ce00:	ea000013 	b	ce54 <unlink+0x1b4>                             
  }                                                                   
                                                                      
  if ( !loc.ops->unlink_h ) {                                         
    ce04:	e592300c 	ldr	r3, [r2, #12]                                 
    ce08:	e3530000 	cmp	r3, #0                                        
    ce0c:	1a000012 	bne	ce5c <unlink+0x1bc>                           
    rtems_filesystem_freenode( &loc );                                
    ce10:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
    ce14:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    ce18:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
    ce1c:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    ce20:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    if ( free_parentloc )                                             
    ce24:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    ce28:	0a000007 	beq	ce4c <unlink+0x1ac>                           <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
    ce2c:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
    ce30:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    ce34:	0a000004 	beq	ce4c <unlink+0x1ac>                           <== NOT EXECUTED
    ce38:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
    ce3c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    ce40:	128d0018 	addne	r0, sp, #24                                 <== NOT EXECUTED
    ce44:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
    ce48:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    ce4c:	eb00015c 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
    ce50:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    ce54:	e5803000 	str	r3, [r0]                                      
    ce58:	ea000018 	b	cec0 <unlink+0x220>                             
  }                                                                   
                                                                      
  result = (*loc.ops->unlink_h)( &parentloc, &loc );                  
    ce5c:	e28d0018 	add	r0, sp, #24                                   
    ce60:	e1a01004 	mov	r1, r4                                        
    ce64:	e1a0e00f 	mov	lr, pc                                        
    ce68:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    ce6c:	e59d3010 	ldr	r3, [sp, #16]                                 
    ce70:	e3530000 	cmp	r3, #0                                        
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*loc.ops->unlink_h)( &parentloc, &loc );                  
    ce74:	e1a06000 	mov	r6, r0                                        
                                                                      
  rtems_filesystem_freenode( &loc );                                  
    ce78:	0a000004 	beq	ce90 <unlink+0x1f0>                           
    ce7c:	e593301c 	ldr	r3, [r3, #28]                                 
    ce80:	e3530000 	cmp	r3, #0                                        
    ce84:	11a00004 	movne	r0, r4                                      
    ce88:	11a0e00f 	movne	lr, pc                                      
    ce8c:	112fff13 	bxne	r3                                           
  if ( free_parentloc )                                               
    ce90:	e3550000 	cmp	r5, #0                                        
    ce94:	0a00000a 	beq	cec4 <unlink+0x224>                           
    rtems_filesystem_freenode( &parentloc );                          
    ce98:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          
    ce9c:	e3530000 	cmp	r3, #0                                        
    cea0:	0a000007 	beq	cec4 <unlink+0x224>                           
    cea4:	e593301c 	ldr	r3, [r3, #28]                                 
    cea8:	e3530000 	cmp	r3, #0                                        
    ceac:	0a000004 	beq	cec4 <unlink+0x224>                           
    ceb0:	e28d0018 	add	r0, sp, #24                                   
    ceb4:	e1a0e00f 	mov	lr, pc                                        
    ceb8:	e12fff13 	bx	r3                                             
    cebc:	ea000000 	b	cec4 <unlink+0x224>                             
    cec0:	e3e06000 	mvn	r6, #0                                        
                                                                      
  return result;                                                      
}                                                                     
    cec4:	e1a00006 	mov	r0, r6                                        
    cec8:	e28dd030 	add	sp, sp, #48	; 0x30                            
    cecc:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00026cc0 <unmount>: */ int unmount( const char *path ) {
   26cc0:	e92d4030 	push	{r4, r5, lr}                                 
   26cc4:	e24dd018 	sub	sp, sp, #24                                   
   26cc8:	e1a05000 	mov	r5, r0                                        
   *    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 ) )
   26ccc:	eb007388 	bl	43af4 <strlen>                                 
   26cd0:	e28d4004 	add	r4, sp, #4                                    
   26cd4:	e1a01000 	mov	r1, r0                                        
   26cd8:	e3a0c001 	mov	ip, #1                                        
   26cdc:	e1a00005 	mov	r0, r5                                        
   26ce0:	e3a02000 	mov	r2, #0                                        
   26ce4:	e1a03004 	mov	r3, r4                                        
   26ce8:	e58dc000 	str	ip, [sp]                                      
   26cec:	ebff8252 	bl	763c <rtems_filesystem_evaluate_path>          
   26cf0:	e3500000 	cmp	r0, #0                                        
   26cf4:	1a00005b 	bne	26e68 <unmount+0x1a8>                         
    return -1;                                                        
                                                                      
  mt_entry     = loc.mt_entry;                                        
   26cf8:	e59d5014 	ldr	r5, [sp, #20]                                 
  fs_mount_loc = &mt_entry->mt_point_node;                            
  fs_root_loc  = &mt_entry->mt_fs_root;                               
   26cfc:	e59d3004 	ldr	r3, [sp, #4]                                  
   26d00:	e595201c 	ldr	r2, [r5, #28]                                 
   26d04:	e1520003 	cmp	r2, r3                                        
   26d08:	e59d3010 	ldr	r3, [sp, #16]                                 
   26d0c:	0a000009 	beq	26d38 <unmount+0x78>                          
  /*                                                                  
   * 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 );                                
   26d10:	e3530000 	cmp	r3, #0                                        
   26d14:	0a000004 	beq	26d2c <unmount+0x6c>                          
   26d18:	e593301c 	ldr	r3, [r3, #28]                                 
   26d1c:	e3530000 	cmp	r3, #0                                        
   26d20:	11a00004 	movne	r0, r4                                      
   26d24:	11a0e00f 	movne	lr, pc                                      
   26d28:	112fff13 	bxne	r3                                           
    rtems_set_errno_and_return_minus_one( EACCES );                   
   26d2c:	eb005873 	bl	3cf00 <__errno>                                
   26d30:	e3a0300d 	mov	r3, #13                                       
   26d34:	ea000021 	b	26dc0 <unmount+0x100>                           
                                                                      
  /*                                                                  
   * Free the loc node and just use the nodes from the mt_entry .     
   */                                                                 
                                                                      
  rtems_filesystem_freenode( &loc );                                  
   26d38:	e3530000 	cmp	r3, #0                                        
   26d3c:	0a000004 	beq	26d54 <unmount+0x94>                          
   26d40:	e593301c 	ldr	r3, [r3, #28]                                 
   26d44:	e3530000 	cmp	r3, #0                                        
   26d48:	11a00004 	movne	r0, r4                                      
   26d4c:	11a0e00f 	movne	lr, pc                                      
   26d50:	112fff13 	bxne	r3                                           
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
    return -1;                                                        
                                                                      
  mt_entry     = loc.mt_entry;                                        
  fs_mount_loc = &mt_entry->mt_point_node;                            
   26d54:	e5953014 	ldr	r3, [r5, #20]                                 
   26d58:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          
   26d5c:	e3530000 	cmp	r3, #0                                        
   26d60:	0a000003 	beq	26d74 <unmount+0xb4>                          
  fs_root_loc  = &mt_entry->mt_fs_root;                               
   26d64:	e5953028 	ldr	r3, [r5, #40]	; 0x28                          
   26d68:	e593302c 	ldr	r3, [r3, #44]	; 0x2c                          
   26d6c:	e3530000 	cmp	r3, #0                                        
   26d70:	1a000002 	bne	26d80 <unmount+0xc0>                          
                                                                      
  if ( !fs_mount_loc->ops->unmount_h )                                
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  if ( !fs_root_loc->ops->fsunmount_me_h )                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   26d74:	eb005861 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   26d78:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   26d7c:	ea00000f 	b	26dc0 <unmount+0x100>                           <== 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 )                
   26d80:	e59f30ec 	ldr	r3, [pc, #236]	; 26e74 <unmount+0x1b4>        
   26d84:	e5933000 	ldr	r3, [r3]                                      
   26d88:	e5933014 	ldr	r3, [r3, #20]                                 
   26d8c:	e1530005 	cmp	r3, r5                                        
   26d90:	0a000008 	beq	26db8 <unmount+0xf8>                          
                                                                      
  /*                                                                  
   *  Verify there are no file systems below the path specified       
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,       
   26d94:	e59f00dc 	ldr	r0, [pc, #220]	; 26e78 <unmount+0x1b8>        
   26d98:	e595102c 	ldr	r1, [r5, #44]	; 0x2c                          
   26d9c:	ebff84ad 	bl	8058 <rtems_filesystem_mount_iterate>          
   26da0:	e3500000 	cmp	r0, #0                                        
   26da4:	1a000003 	bne	26db8 <unmount+0xf8>                          
   *  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 )             
   26da8:	e1a00005 	mov	r0, r5                                        
   26dac:	ebff8313 	bl	7a00 <rtems_libio_is_open_files_in_fs>         
   26db0:	e3500001 	cmp	r0, #1                                        
   26db4:	1a000003 	bne	26dc8 <unmount+0x108>                         
    rtems_set_errno_and_return_minus_one( EBUSY );                    
   26db8:	eb005850 	bl	3cf00 <__errno>                                
   26dbc:	e3a03010 	mov	r3, #16                                       
   26dc0:	e5803000 	str	r3, [r0]                                      
   26dc4:	ea000027 	b	26e68 <unmount+0x1a8>                           
   * 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 )             
   26dc8:	e5953014 	ldr	r3, [r5, #20]                                 
   26dcc:	e1a00005 	mov	r0, r5                                        
   26dd0:	e1a0e00f 	mov	lr, pc                                        
   26dd4:	e593f028 	ldr	pc, [r3, #40]	; 0x28                          
   26dd8:	e2504000 	subs	r4, r0, #0                                   
   26ddc:	1a000021 	bne	26e68 <unmount+0x1a8>                         
   *  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){          
   26de0:	e5953028 	ldr	r3, [r5, #40]	; 0x28                          
   26de4:	e1a00005 	mov	r0, r5                                        
   26de8:	e1a0e00f 	mov	lr, pc                                        
   26dec:	e593f02c 	ldr	pc, [r3, #44]	; 0x2c                          
   26df0:	e2501000 	subs	r1, r0, #0                                   
   26df4:	0a000007 	beq	26e18 <unmount+0x158>                         
    if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )             
   26df8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   26dfc:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
   26e00:	e1a0e00f 	mov	lr, pc                                        <== NOT EXECUTED
   26e04:	e593f020 	ldr	pc, [r3, #32]                                 <== NOT EXECUTED
   26e08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   26e0c:	0a000015 	beq	26e68 <unmount+0x1a8>                         <== NOT EXECUTED
      rtems_fatal_error_occurred( 0 );                                
   26e10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
   26e14:	ebff9479 	bl	c000 <rtems_fatal_error_occurred>              <== 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 );
   26e18:	e59f405c 	ldr	r4, [pc, #92]	; 26e7c <unmount+0x1bc>         
   26e1c:	e1a02001 	mov	r2, r1                                        
   26e20:	e5940000 	ldr	r0, [r4]                                      
   26e24:	ebff92a5 	bl	b8c0 <rtems_semaphore_obtain>                  
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
   26e28:	e1a00005 	mov	r0, r5                                        
   26e2c:	ebff9583 	bl	c440 <_Chain_Extract>                          
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
   26e30:	e5940000 	ldr	r0, [r4]                                      
   26e34:	ebff92e7 	bl	b9d8 <rtems_semaphore_release>                 
  /*                                                                  
   *  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 );                          
   26e38:	e5953014 	ldr	r3, [r5, #20]                                 
   26e3c:	e3530000 	cmp	r3, #0                                        
   26e40:	0a000004 	beq	26e58 <unmount+0x198>                         
   26e44:	e593301c 	ldr	r3, [r3, #28]                                 
   26e48:	e3530000 	cmp	r3, #0                                        
   26e4c:	12850008 	addne	r0, r5, #8                                  
   26e50:	11a0e00f 	movne	lr, pc                                      
   26e54:	112fff13 	bxne	r3                                           
  free( mt_entry );                                                   
   26e58:	e1a00005 	mov	r0, r5                                        
   26e5c:	ebff8214 	bl	76b4 <free>                                    
   26e60:	e3a00000 	mov	r0, #0                                        
                                                                      
  return 0;                                                           
   26e64:	ea000000 	b	26e6c <unmount+0x1ac>                           
   26e68:	e3e00000 	mvn	r0, #0                                        
}                                                                     
   26e6c:	e28dd018 	add	sp, sp, #24                                   
   26e70:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

00026e80 <utime>: int utime( const char *path, const struct utimbuf *times ) {
   26e80:	e92d4070 	push	{r4, r5, r6, lr}                             
   26e84:	e24dd018 	sub	sp, sp, #24                                   
   26e88:	e1a05001 	mov	r5, r1                                        
   26e8c:	e1a06000 	mov	r6, r0                                        
  rtems_filesystem_location_info_t   temp_loc;                        
  int                                result;                          
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
   26e90:	eb007317 	bl	43af4 <strlen>                                 
   26e94:	e28d4004 	add	r4, sp, #4                                    
   26e98:	e1a01000 	mov	r1, r0                                        
   26e9c:	e3a0c001 	mov	ip, #1                                        
   26ea0:	e1a00006 	mov	r0, r6                                        
   26ea4:	e3a02000 	mov	r2, #0                                        
   26ea8:	e1a03004 	mov	r3, r4                                        
   26eac:	e58dc000 	str	ip, [sp]                                      
   26eb0:	ebff81e1 	bl	763c <rtems_filesystem_evaluate_path>          
   26eb4:	e3500000 	cmp	r0, #0                                        
   26eb8:	1a00000b 	bne	26eec <utime+0x6c>                            
    return -1;                                                        
                                                                      
  if ( !temp_loc.ops->utime_h ){                                      
   26ebc:	e59d2010 	ldr	r2, [sp, #16]                                 
   26ec0:	e5923030 	ldr	r3, [r2, #48]	; 0x30                          
   26ec4:	e3530000 	cmp	r3, #0                                        
   26ec8:	1a000009 	bne	26ef4 <utime+0x74>                            
    rtems_filesystem_freenode( &temp_loc );                           
   26ecc:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
   26ed0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
   26ed4:	11a00004 	movne	r0, r4                                      <== NOT EXECUTED
   26ed8:	11a0e00f 	movne	lr, pc                                      <== NOT EXECUTED
   26edc:	112fff13 	bxne	r3                                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   26ee0:	eb005806 	bl	3cf00 <__errno>                                <== NOT EXECUTED
   26ee4:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   26ee8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   26eec:	e3e05000 	mvn	r5, #0                                        
   26ef0:	ea00000c 	b	26f28 <utime+0xa8>                              
  }                                                                   
                                                                      
  result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
   26ef4:	e8950006 	ldm	r5, {r1, r2}                                  
   26ef8:	e1a00004 	mov	r0, r4                                        
   26efc:	e1a0e00f 	mov	lr, pc                                        
   26f00:	e12fff13 	bx	r3                                             
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
   26f04:	e59d3010 	ldr	r3, [sp, #16]                                 
   26f08:	e3530000 	cmp	r3, #0                                        
  if ( !temp_loc.ops->utime_h ){                                      
    rtems_filesystem_freenode( &temp_loc );                           
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
   26f0c:	e1a05000 	mov	r5, r0                                        
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
   26f10:	0a000004 	beq	26f28 <utime+0xa8>                            
   26f14:	e593301c 	ldr	r3, [r3, #28]                                 
   26f18:	e3530000 	cmp	r3, #0                                        
   26f1c:	11a00004 	movne	r0, r4                                      
   26f20:	11a0e00f 	movne	lr, pc                                      
   26f24:	112fff13 	bxne	r3                                           
                                                                      
  return result;                                                      
}                                                                     
   26f28:	e1a00005 	mov	r0, r5                                        
   26f2c:	e28dd018 	add	sp, sp, #24                                   
   26f30:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00019178 <write>: ) { ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd );
   19178:	e59f30b0 	ldr	r3, [pc, #176]	; 19230 <write+0xb8>           
   1917c:	e5933000 	ldr	r3, [r3]                                      
   19180:	e1500003 	cmp	r0, r3                                        
ssize_t write(                                                        
  int         fd,                                                     
  const void *buffer,                                                 
  size_t      count                                                   
)                                                                     
{                                                                     
   19184:	e92d4070 	push	{r4, r5, r6, lr}                             
   19188:	e1a05001 	mov	r5, r1                                        
  ssize_t  rc;                                                        
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
   1918c:	2a00000f 	bcs	191d0 <write+0x58>                            
  iop = rtems_libio_iop( fd );                                        
   19190:	e59f309c 	ldr	r3, [pc, #156]	; 19234 <write+0xbc>           
   19194:	e5934000 	ldr	r4, [r3]                                      
   19198:	e0844300 	add	r4, r4, r0, lsl #6                            
  rtems_libio_check_is_open( iop );                                   
   1919c:	e5943014 	ldr	r3, [r4, #20]                                 
   191a0:	e3130c01 	tst	r3, #256	; 0x100                              
   191a4:	0a000009 	beq	191d0 <write+0x58>                            
  rtems_libio_check_buffer( buffer );                                 
   191a8:	e3510000 	cmp	r1, #0                                        
   191ac:	1a000002 	bne	191bc <write+0x44>                            
   191b0:	ebffd083 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   191b4:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
   191b8:	ea00000d 	b	191f4 <write+0x7c>                              <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
   191bc:	e3520000 	cmp	r2, #0                                        
   191c0:	01a00002 	moveq	r0, r2                                      
   191c4:	08bd8070 	popeq	{r4, r5, r6, pc}                            
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
   191c8:	e3130004 	tst	r3, #4                                        
   191cc:	1a000002 	bne	191dc <write+0x64>                            
   191d0:	ebffd07b 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   191d4:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
   191d8:	ea000005 	b	191f4 <write+0x7c>                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the write() request.                                
   */                                                                 
                                                                      
  if ( !iop->handlers->write_h )                                      
   191dc:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          
   191e0:	e593300c 	ldr	r3, [r3, #12]                                 
   191e4:	e3530000 	cmp	r3, #0                                        
   191e8:	1a000004 	bne	19200 <write+0x88>                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
   191ec:	ebffd074 	bl	d3c4 <__errno>                                 <== NOT EXECUTED
   191f0:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
   191f4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
   191f8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
   191fc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  rc = (*iop->handlers->write_h)( iop, buffer, count );               
   19200:	e1a00004 	mov	r0, r4                                        
   19204:	e1a0e00f 	mov	lr, pc                                        
   19208:	e12fff13 	bx	r3                                             
                                                                      
  if ( rc > 0 )                                                       
   1920c:	e3500000 	cmp	r0, #0                                        
   19210:	d8bd8070 	pople	{r4, r5, r6, pc}                            
    iop->offset += rc;                                                
   19214:	e284600c 	add	r6, r4, #12                                   
   19218:	e8960060 	ldm	r6, {r5, r6}                                  
   1921c:	e0952000 	adds	r2, r5, r0                                   
   19220:	e0a63fc0 	adc	r3, r6, r0, asr #31                           
   19224:	e584200c 	str	r2, [r4, #12]                                 
   19228:	e5843010 	str	r3, [r4, #16]                                 
                                                                      
  return rc;                                                          
}                                                                     
   1922c:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

00005b6c <writev>: int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd );
    5b6c:	e59f3158 	ldr	r3, [pc, #344]	; 5ccc <writev+0x160>          
    5b70:	e5933000 	ldr	r3, [r3]                                      
    5b74:	e1500003 	cmp	r0, r3                                        
ssize_t writev(                                                       
  int                 fd,                                             
  const struct iovec *iov,                                            
  int                 iovcnt                                          
)                                                                     
{                                                                     
    5b78:	e92d49f0 	push	{r4, r5, r6, r7, r8, fp, lr}                 
    5b7c:	e1a08002 	mov	r8, r2                                        
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  ssize_t        old;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
    5b80:	2a000007 	bcs	5ba4 <writev+0x38>                            
  iop = rtems_libio_iop( fd );                                        
    5b84:	e59f3144 	ldr	r3, [pc, #324]	; 5cd0 <writev+0x164>          
    5b88:	e5936000 	ldr	r6, [r3]                                      
    5b8c:	e0866300 	add	r6, r6, r0, lsl #6                            
  rtems_libio_check_is_open( iop );                                   
    5b90:	e5963014 	ldr	r3, [r6, #20]                                 
    5b94:	e3130c01 	tst	r3, #256	; 0x100                              
    5b98:	0a000001 	beq	5ba4 <writev+0x38>                            
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
    5b9c:	e3130004 	tst	r3, #4                                        
    5ba0:	1a000002 	bne	5bb0 <writev+0x44>                            
    5ba4:	eb00222c 	bl	e45c <__errno>                                 
    5ba8:	e3a03009 	mov	r3, #9                                        
    5bac:	ea000020 	b	5c34 <writev+0xc8>                              
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
    5bb0:	e3510000 	cmp	r1, #0                                        
    5bb4:	0a00001c 	beq	5c2c <writev+0xc0>                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
    5bb8:	e3520000 	cmp	r2, #0                                        
    5bbc:	da00001a 	ble	5c2c <writev+0xc0>                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
    5bc0:	e3520b01 	cmp	r2, #1024	; 0x400                             
    5bc4:	ca000018 	bgt	5c2c <writev+0xc0>                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !iop->handlers->write_h )                                      
    5bc8:	e596303c 	ldr	r3, [r6, #60]	; 0x3c                          
    5bcc:	e593300c 	ldr	r3, [r3, #12]                                 
    5bd0:	e3530000 	cmp	r3, #0                                        
    5bd4:	1a000002 	bne	5be4 <writev+0x78>                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
    5bd8:	eb00221f 	bl	e45c <__errno>                                 <== NOT EXECUTED
    5bdc:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
    5be0:	ea000013 	b	5c34 <writev+0xc8>                              <== NOT EXECUTED
    5be4:	e3a03000 	mov	r3, #0                                        
    5be8:	e1a05001 	mov	r5, r1                                        
    5bec:	e1a02001 	mov	r2, r1                                        
    5bf0:	e3a07001 	mov	r7, #1                                        
    5bf4:	e1a04003 	mov	r4, r3                                        
   *  entering the write loop.                                        
   */                                                                 
  all_zeros = true;                                                   
  for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {                    
                                                                      
    if ( !iov[v].iov_base )                                           
    5bf8:	e5921000 	ldr	r1, [r2]                                      
    5bfc:	e3510000 	cmp	r1, #0                                        
   *  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++ ) {                    
    5c00:	e2833001 	add	r3, r3, #1                                    
                                                                      
    if ( !iov[v].iov_base )                                           
    5c04:	0a000008 	beq	5c2c <writev+0xc0>                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len < 0 )                                         
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
    5c08:	e5920004 	ldr	r0, [r2, #4]                                  
      all_zeros = false;                                              
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    5c0c:	e0841000 	add	r1, r4, r0                                    
    if ( total < old || total > SSIZE_MAX )                           
    5c10:	e1510004 	cmp	r1, r4                                        
    5c14:	a3a04000 	movge	r4, #0                                      
    5c18:	b3a04001 	movlt	r4, #1                                      
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len < 0 )                                         
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
    5c1c:	e3500000 	cmp	r0, #0                                        
    5c20:	13a07000 	movne	r7, #0                                      
      all_zeros = false;                                              
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
    5c24:	e1944fa1 	orrs	r4, r4, r1, lsr #31                          
    5c28:	0a000003 	beq	5c3c <writev+0xd0>                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
    5c2c:	eb00220a 	bl	e45c <__errno>                                 
    5c30:	e3a03016 	mov	r3, #22                                       
    5c34:	e5803000 	str	r3, [r0]                                      
    5c38:	ea000011 	b	5c84 <writev+0x118>                             
   *  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++ ) {                    
    5c3c:	e1530008 	cmp	r3, r8                                        
    5c40:	e2822008 	add	r2, r2, #8                                    
    5c44:	b1a04001 	movlt	r4, r1                                      
    5c48:	baffffea 	blt	5bf8 <writev+0x8c>                            
  }                                                                   
                                                                      
  /*                                                                  
   * A writev with all zeros is supposed to have no effect per OpenGroup.
   */                                                                 
  if ( all_zeros == true ) {                                          
    5c4c:	e3570000 	cmp	r7, #0                                        
    5c50:	1a00001b 	bne	5cc4 <writev+0x158>                           
    5c54:	e1a04007 	mov	r4, r7                                        
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    /* all zero lengths has no effect */                              
    if ( iov[v].iov_len == 0 )                                        
    5c58:	e5952004 	ldr	r2, [r5, #4]                                  
    5c5c:	e3520000 	cmp	r2, #0                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    5c60:	e2877001 	add	r7, r7, #1                                    
    /* all zero lengths has no effect */                              
    if ( iov[v].iov_len == 0 )                                        
    5c64:	0a000013 	beq	5cb8 <writev+0x14c>                           
      continue;                                                       
                                                                      
    bytes = (*iop->handlers->write_h)( iop, iov[v].iov_base, iov[v].iov_len );
    5c68:	e5951000 	ldr	r1, [r5]                                      
    5c6c:	e596303c 	ldr	r3, [r6, #60]	; 0x3c                          
    5c70:	e1a00006 	mov	r0, r6                                        
    5c74:	e1a0e00f 	mov	lr, pc                                        
    5c78:	e593f00c 	ldr	pc, [r3, #12]                                 
                                                                      
    if ( bytes < 0 )                                                  
    5c7c:	e3500000 	cmp	r0, #0                                        
    5c80:	aa000001 	bge	5c8c <writev+0x120>                           
    5c84:	e3e04000 	mvn	r4, #0                                        
    5c88:	ea00000d 	b	5cc4 <writev+0x158>                             
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
    5c8c:	0a000006 	beq	5cac <writev+0x140>                           
      iop->offset += bytes;                                           
    5c90:	e286c00c 	add	ip, r6, #12                                   
    5c94:	e89c1800 	ldm	ip, {fp, ip}                                  
    5c98:	e09b2000 	adds	r2, fp, r0                                   
    5c9c:	e0ac3fc0 	adc	r3, ip, r0, asr #31                           
    5ca0:	e586200c 	str	r2, [r6, #12]                                 
    5ca4:	e5863010 	str	r3, [r6, #16]                                 
      total       += bytes;                                           
    5ca8:	e0844000 	add	r4, r4, r0                                    
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
    5cac:	e5953004 	ldr	r3, [r5, #4]                                  
    5cb0:	e1500003 	cmp	r0, r3                                        
    5cb4:	1a000002 	bne	5cc4 <writev+0x158>                           
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    5cb8:	e1570008 	cmp	r7, r8                                        
    5cbc:	e2855008 	add	r5, r5, #8                                    
    5cc0:	baffffe4 	blt	5c58 <writev+0xec>                            
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
    5cc4:	e1a00004 	mov	r0, r4                                        
    5cc8:	e8bd89f0 	pop	{r4, r5, r6, r7, r8, fp, pc}